diff options
Diffstat (limited to 'src/code.l')
| -rw-r--r-- | src/code.l | 5175 |
1 files changed, 2642 insertions, 2533 deletions
@@ -16,6 +16,8 @@ */ %option never-interactive %option prefix="codeYY" +%option reentrant +%option extra-type="struct codeYY_state *" %{ @@ -28,6 +30,7 @@ #include <qregexp.h> #include <qdir.h> +#include "code.h" #include "entry.h" #include "doxygen.h" #include "message.h" @@ -58,80 +61,6 @@ * statics */ -static CodeOutputInterface * g_code; - -static ClassSDict *g_codeClassSDict = 0; -static QCString g_curClassName; -static QStrList g_curClassBases; - -static QCString g_parmType; -static QCString g_parmName; - -static const char * g_inputString; //!< the code fragment as text -static int g_inputPosition; //!< read offset during parsing -static int g_inputLines; //!< number of line in the code fragment -static int g_yyLineNr; //!< current line number -static int g_yyColNr; //!< current column number -static bool g_needsTermination; - -static bool g_exampleBlock; -static QCString g_exampleName; -static QCString g_exampleFile; - -static bool g_insideTemplate = FALSE; -static QCString g_type; -static QCString g_name; -static QCString g_args; -static QCString g_classScope; -static QCString g_realScope; -static QStack<int> g_scopeStack; //!< 1 if bracket starts a scope, - // 2 for internal blocks -static int g_anchorCount; -static FileDef * g_sourceFileDef; -static bool g_lineNumbers; -static Definition * g_currentDefinition; -static MemberDef * g_currentMemberDef; -static bool g_includeCodeFragment; -static const char * g_currentFontClass; -static bool g_searchingForBody; -static bool g_insideBody; -static int g_bodyCurlyCount; -static QCString g_saveName; -static QCString g_saveType; -static QCString g_delimiter; - -static int g_bracketCount = 0; -static int g_curlyCount = 0; -static int g_sharpCount = 0; -static bool g_inFunctionTryBlock = FALSE; -static bool g_inForEachExpression = FALSE; - -static int g_lastTemplCastContext; -static int g_lastSpecialCContext; -static int g_lastStringContext; -static int g_lastSkipCppContext; -static int g_lastVerbStringContext; -static int g_lastObjCCallContext; -static int g_memCallContext; -static int g_lastCContext; -static int g_skipInlineInitContext; - -static bool g_insideCpp; -static bool g_insideObjC; -static bool g_insideJava; -static bool g_insideCS; -static bool g_insidePHP; -static bool g_insideProtocolList; -static bool g_insideSlice; - -static bool g_lexInit = FALSE; - -static QStack<int> g_classScopeLengthStack; - -static int g_prefixed_with_this_keyword = FALSE; -static const Definition *g_searchCtx; -static bool g_collectXRefs; - // context for an Objective-C method call struct ObjCCallCtx { @@ -147,31 +76,6 @@ struct ObjCCallCtx int braceCount; }; -// globals for objective-C method calls -static ObjCCallCtx *g_currentCtx=0; -static int g_currentCtxId=0; -static int g_currentNameId=0; -static int g_currentObjId=0; -static int g_currentWordId=0; -static int g_currentCommentId=0; -static QStack<ObjCCallCtx> g_contextStack; -static QIntDict<ObjCCallCtx> g_contextDict; -static QIntDict<QCString> g_nameDict; -static QIntDict<QCString> g_objectDict; -static QIntDict<QCString> g_wordDict; -static QIntDict<QCString> g_commentDict; -static int g_braceCount=0; - -static void saveObjCContext(); -static void restoreObjCContext(); - -static const char *stateToString(int state); - -static QCString g_forceTagReference; - - -//------------------------------------------------------------------- - /*! Represents a stack of variable to class mappings as found in the * code. Each scope is enclosed in pushScope() and popScope() calls. * Variables are added by calling addVariables() and one can search @@ -227,7 +131,7 @@ class VariableContext m_scopes.clear(); } - void addVariable(const QCString &type,const QCString &name); + void addVariable(yyscan_t yyscanner,const QCString &type,const QCString &name); ClassDef *findVariable(const QCString &name); int count() const { return m_scopes.count(); } @@ -237,8 +141,2115 @@ class VariableContext QList<Scope> m_scopes; }; -void VariableContext::addVariable(const QCString &type,const QCString &name) +//------------------------------------------------------------------- + +class CallContext +{ + public: + struct Ctx + { + Ctx(QCString _name, QCString _type) : name(_name), type(_type), d(0) {} + QCString name; + QCString type; + const Definition *d; + }; + + CallContext() + { + m_defList.append(new Ctx("","")); + m_defList.setAutoDelete(TRUE); + } + virtual ~CallContext() {} + void setScope(const Definition *d) + { + Ctx *ctx = m_defList.getLast(); + if (ctx) + { + DBG_CTX((stderr,"** Set call context %s (%p)\n",d==0 ? "<null>" : d->name().data(),d)); + ctx->d=d; + } + } + void pushScope(QCString _name, QCString _type) + { + m_defList.append(new Ctx(_name,_type)); + DBG_CTX((stderr,"** Push call context %d\n",m_defList.count())); + } + void popScope(QCString &_name, QCString &_type) + { + if (m_defList.count()>1) + { + DBG_CTX((stderr,"** Pop call context %d\n",m_defList.count())); + Ctx *ctx = m_defList.getLast(); + if (ctx) + { + _name = ctx->name; + _type = ctx->type; + } + m_defList.removeLast(); + } + else + { + DBG_CTX((stderr,"** ILLEGAL: Pop call context\n")); + } + } + void clear() + { + DBG_CTX((stderr,"** Clear call context\n")); + m_defList.clear(); + m_defList.append(new Ctx("","")); + } + const Definition *getScope() const + { + Ctx *ctx = m_defList.getLast(); + if (ctx) return ctx->d; else return 0; + } + + private: + QList<Ctx> m_defList; +}; + + +struct codeYY_state +{ + CodeOutputInterface * code = 0; + + ClassSDict *codeClassSDict = 0; + QCString curClassName; + QStrList curClassBases; + + QCString parmType; + QCString parmName; + + const char * inputString = 0; //!< the code fragment as text + int inputPosition = 0; //!< read offset during parsing + int inputLines = 0; //!< number of line in the code fragment + int yyLineNr = 0; //!< current line number + int yyColNr = 0; //!< current column number + bool needsTermination = FALSE; + + bool exampleBlock = FALSE; + QCString exampleName; + QCString exampleFile; + + bool insideTemplate = FALSE; + QCString type; + QCString name; + QCString args; + QCString classScope; + QCString realScope; + QStack<int> scopeStack; //!< 1 if bracket starts a scope, + // 2 for internal blocks + int anchorCount = 0; + FileDef * sourceFileDef = 0; + bool lineNumbers = FALSE; + Definition * currentDefinition = 0; + MemberDef * currentMemberDef = 0; + bool includeCodeFragment = FALSE; + const char * currentFontClass = 0; + bool searchingForBody = FALSE; + bool insideBody = FALSE; + int bodyCurlyCount = 0; + QCString saveName; + QCString saveType; + QCString delimiter; + + int bracketCount = 0; + int curlyCount = 0; + int sharpCount = 0; + bool inFunctionTryBlock = FALSE; + bool inForEachExpression = FALSE; + + int lastTemplCastContext = 0; + int lastSpecialCContext = 0; + int lastStringContext = 0; + int lastSkipCppContext = 0; + int lastVerbStringContext = 0; + int lastObjCCallContext = 0; + int memCallContext = 0; + int lastCContext = 0; + int skipInlineInitContext = 0; + + SrcLangExt lang = SrcLangExt_Unknown; + bool insideObjC = FALSE; + bool insideProtocolList = FALSE; + + bool lexInit = FALSE; + + QStack<int> classScopeLengthStack; + + int prefixed_with_this_keyword = FALSE; + const Definition *searchCtx = 0; + bool collectXRefs = FALSE; + + ObjCCallCtx * currentCtx=0; + int currentCtxId=0; + int currentNameId=0; + int currentObjId=0; + int currentWordId=0; + int currentCommentId=0; + QStack<ObjCCallCtx> contextStack; + QIntDict<ObjCCallCtx> contextDict; + QIntDict<QCString> nameDict; + QIntDict<QCString> objectDict; + QIntDict<QCString> wordDict; + QIntDict<QCString> commentDict; + int braceCount=0; + + QCString forceTagReference; + VariableContext theVarContext; + CallContext theCallContext; +}; + +static bool isCastKeyword(const QCString &s); + +//------------------------------------------------------------------- + +static void saveObjCContext(yyscan_t yyscanner); +static void restoreObjCContext(yyscan_t yyscanner); +static const char *stateToString(yyscan_t yyscanner,int state); +static void addUsingDirective(yyscan_t yyscanner,const char *name); +static void pushScope(yyscan_t yyscanner,const char *s); +static void popScope(yyscan_t yyscanner); +static void setCurrentDoc(yyscan_t yyscanner,const QCString &anchor); +static void addToSearchIndex(yyscan_t yyscanner,const char *text); +static void setClassScope(yyscan_t yyscanner,const QCString &name); +static void startCodeLine(yyscan_t yyscanner); +static void endCodeLine(yyscan_t yyscanner); +static void nextCodeLine(yyscan_t yyscanner); +static void startFontClass(yyscan_t yyscanner,const char *s); +static void endFontClass(yyscan_t yyscanner); +static void codifyLines(yyscan_t yyscanner,const char *text); +static void writeMultiLineCodeLink(yyscan_t yyscanner,CodeOutputInterface &ol, + const Definition *d, + const char *text); +static void addType(yyscan_t yyscanner); +static void addParmType(yyscan_t yyscanner); +static void addUsingDirective(yyscan_t yyscanner,const char *name); +static void setParameterList(yyscan_t yyscanner,const MemberDef *md); +static const ClassDef *stripClassName(yyscan_t yyscanner,const char *s,Definition *d); +static MemberDef *setCallContextForVar(yyscan_t yyscanner,const QCString &name); +static void updateCallContextForSmartPointer(yyscan_t yyscanner); +static bool getLinkInScope(yyscan_t yyscanner,const QCString &c, // scope + const QCString &m, // member + const char *memberText, // exact text + CodeOutputInterface &ol, + const char *text, + bool varOnly=FALSE + ); +static bool getLink(yyscan_t yyscanner,const char *className, + const char *memberName, + CodeOutputInterface &ol, + const char *text=0, + bool varOnly=FALSE); +static void generateClassOrGlobalLink(yyscan_t yyscanner,CodeOutputInterface &ol,const char *clName, + bool typeOnly=FALSE,bool varOnly=FALSE); +static bool generateClassMemberLink(yyscan_t yyscanner,CodeOutputInterface &ol,MemberDef *xmd,const char *memName); +static bool generateClassMemberLink(yyscan_t yyscanner,CodeOutputInterface &ol,const Definition *def,const char *memName); +static void generateMemberLink(yyscan_t yyscanner,CodeOutputInterface &ol,const QCString &varName, + const char *memName); +static void generatePHPVariableLink(yyscan_t yyscanner,CodeOutputInterface &ol,const char *varName); +static void generateFunctionLink(yyscan_t yyscanner,CodeOutputInterface &ol,const char *funcName); +static int countLines(yyscan_t yyscanner); +static void writeObjCMethodCall(yyscan_t yyscanner,ObjCCallCtx *ctx); +static QCString escapeName(yyscan_t yyscanner,const char *s); +static QCString escapeObject(yyscan_t yyscanner,const char *s); +static QCString escapeWord(yyscan_t yyscanner,const char *s); +static QCString escapeComment(yyscan_t yyscanner,const char *s); +static bool skipLanguageSpecificKeyword(yyscan_t yyscanner,const QCString &kw); +static int yyread(yyscan_t yyscanner,char *buf,int max_size); + + +/* ----------------------------------------------------------------- + */ +#undef YY_INPUT +#define YY_INPUT(buf,result,max_size) result=yyread(yyscanner,buf,max_size); + + +%} + +B [ \t] +BN [ \t\n\r] +ID "$"?[a-z_A-Z\x80-\xFF][a-z_A-Z0-9\x80-\xFF]* +SEP ("::"|"\\") +SCOPENAME ({SEP}{BN}*)?({ID}{BN}*{SEP}{BN}*)*("~"{BN}*)?{ID} +TEMPLIST "<"[^\"\}\{\(\)\/\n\>]*">" +SCOPETNAME (((({ID}{TEMPLIST}?){BN}*)?{SEP}{BN}*)*)((~{BN}*)?{ID}) +SCOPEPREFIX ({ID}{TEMPLIST}?{BN}*{SEP}{BN}*)+ +KEYWORD_OBJC ("@public"|"@private"|"@protected"|"@class"|"@implementation"|"@interface"|"@end"|"@selector"|"@protocol"|"@optional"|"@required"|"@throw"|"@synthesize"|"@property") +KEYWORD ("asm"|"__assume"|"auto"|"class"|"const"|"delete"|"enum"|"explicit"|"extern"|"false"|"friend"|"gcnew"|"gcroot"|"set"|"get"|"inline"|"internal"|"mutable"|"namespace"|"new"|"null"|"nullptr"|"override"|"operator"|"pin_ptr"|"private"|"protected"|"public"|"raise"|"register"|"remove"|"self"|"sizeof"|"static"|"struct"|"__super"|"function"|"template"|"generic"|"this"|"true"|"typedef"|"typeid"|"typename"|"union"|"using"|"virtual"|"volatile"|"abstract"|"final"|"import"|"synchronized"|"transient"|"alignas"|"alignof"|{KEYWORD_OBJC}) +FLOWKW ("break"|"catch"|"continue"|"default"|"do"|"else"|"finally"|"return"|"switch"|"throw"|"throws"|"@catch"|"@finally") +FLOWCONDITION ("case"|"for"|"foreach"|"for each"|"goto"|"if"|"try"|"while"|"@try") +TYPEKW ("bool"|"byte"|"char"|"double"|"float"|"int"|"long"|"object"|"short"|"signed"|"unsigned"|"void"|"wchar_t"|"size_t"|"boolean"|"id"|"SEL"|"string"|"nullptr") +TYPEKWSL ("LocalObject"|"Object"|"Value") +CASTKW ("const_cast"|"dynamic_cast"|"reinterpret_cast"|"static_cast") +CHARLIT (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^' \\\n]{1,4}"'")) +ARITHOP "+"|"-"|"/"|"*"|"%"|"--"|"++" +ASSIGNOP "="|"*="|"/="|"%="|"+="|"-="|"<<="|">>="|"&="|"^="|"|=" +LOGICOP "=="|"!="|">"|"<"|">="|"<="|"&&"|"||"|"!" +BITOP "&"|"|"|"^"|"<<"|">>"|"~" +OPERATOR {ARITHOP}|{ASSIGNOP}|{LOGICOP}|{BITOP} +RAWBEGIN (u|U|L|u8)?R\"[^ \t\(\)\\]{0,16}"(" +RAWEND ")"[^ \t\(\)\\]{0,16}\" + +%option noyywrap + +%x SkipString +%x SkipStringS +%x SkipVerbString +%x SkipCPP +%x SkipComment +%x SkipCxxComment +%x RemoveSpecialCComment +%x StripSpecialCComment +%x Body +%x FuncCall +%x MemberCall +%x MemberCall2 +%x SkipInits +%x ClassName +%x AlignAs +%x AlignAsEnd +%x PackageName +%x ClassVar +%x CppCliTypeModifierFollowup +%x Bases +%x SkipSharp +%x ReadInclude +%x TemplDecl +%x TemplCast +%x CallEnd +%x ObjCMethod +%x ObjCParams +%x ObjCParamType +%x ObjCCall +%x ObjCMName +%x ObjCSkipStr +%x ObjCCallComment +%x OldStyleArgs +%x UsingName +%x RawString +%x InlineInit + +%% + +<*>\x0d +<Body>^([ \t]*"#"[ \t]*("include"|"import")[ \t]*)("<"|"\"") { + startFontClass(yyscanner,"preprocessor"); + yyextra->code->codify(yytext); + BEGIN( ReadInclude ); + } +<Body>("@interface"|"@implementation"|"@protocol")[ \t\n]+ { + yyextra->insideObjC=TRUE; + startFontClass(yyscanner,"keyword"); + codifyLines(yyscanner,yytext); + endFontClass(yyscanner); + if (!yyextra->insideTemplate) + BEGIN( ClassName ); + } +<Body>(("public"|"private"){B}+)?("ref"|"value"|"interface"|"enum"){B}+("class"|"struct") { + if (yyextra->insideTemplate) REJECT; + startFontClass(yyscanner,"keyword"); + codifyLines(yyscanner,yytext); + endFontClass(yyscanner); + BEGIN( ClassName ); + } +<Body>"property"|"event"/{BN}* { + if (yyextra->insideTemplate) REJECT; + startFontClass(yyscanner,"keyword"); + codifyLines(yyscanner,yytext); + endFontClass(yyscanner); + } +<Body>(KEYWORD_CPPCLI_DATATYPE|("partial"{B}+)?"class"|"struct"|"union"|"namespace"|"interface"){B}+ { + startFontClass(yyscanner,"keyword"); + codifyLines(yyscanner,yytext); + endFontClass(yyscanner); + if (!yyextra->insideTemplate) + BEGIN( ClassName ); + } +<Body>("package")[ \t\n]+ { + startFontClass(yyscanner,"keyword"); + codifyLines(yyscanner,yytext); + endFontClass(yyscanner); + BEGIN( PackageName ); + } +<ClassVar>\n { + if (!yyextra->insideObjC) REJECT; + codifyLines(yyscanner,yytext); + BEGIN(Body); + } +<Body,ClassVar,Bases>"-"|"+" { + if (!yyextra->insideObjC || yyextra->insideBody) + { + yyextra->code->codify(yytext); + } + else // Start of Objective-C method + { + //printf("Method!\n"); + yyextra->code->codify(yytext); + BEGIN(ObjCMethod); + } + } +<ObjCMethod>":" { + yyextra->code->codify(yytext); + BEGIN(ObjCParams); + } +<ObjCParams>"(" { + yyextra->code->codify(yytext); + BEGIN(ObjCParamType); + } +<ObjCParams,ObjCMethod>";"|"{" { + yyextra->code->codify(yytext); + if (*yytext=='{') + { + if (yyextra->searchingForBody) + { + yyextra->searchingForBody=FALSE; + yyextra->insideBody=TRUE; + } + if (yyextra->insideBody) yyextra->bodyCurlyCount++; + if (!yyextra->curClassName.isEmpty()) // valid class name + { + pushScope(yyscanner,yyextra->curClassName); + DBG_CTX((stderr,"** scope stack push SCOPEBLOCK\n")); + yyextra->scopeStack.push(SCOPEBLOCK); + } + } + yyextra->type.resize(0); + yyextra->name.resize(0); + BEGIN(Body); + } +<ObjCParams>{ID}{B}*":" { + yyextra->code->codify(yytext); + } +<ObjCParamType>{TYPEKW} { + startFontClass(yyscanner,"keywordtype"); + yyextra->code->codify(yytext); + endFontClass(yyscanner); + yyextra->parmType=yytext; + } +<ObjCParamType>{ID} { + generateClassOrGlobalLink(yyscanner,*yyextra->code,yytext); + yyextra->parmType=yytext; + } +<ObjCParamType>")" { + yyextra->code->codify(yytext); + BEGIN(ObjCParams); + } +<ObjCParams>{ID} { + yyextra->code->codify(yytext); + yyextra->parmName=yytext; + yyextra->theVarContext.addVariable(yyscanner,yyextra->parmType,yyextra->parmName); + yyextra->parmType.resize(0);yyextra->parmName.resize(0); + } +<ObjCMethod,ObjCParams,ObjCParamType>{ID} { + generateClassOrGlobalLink(yyscanner,*yyextra->code,yytext); + } +<ObjCMethod,ObjCParams,ObjCParamType>. { + yyextra->code->codify(yytext); + } +<ObjCMethod,ObjCParams,ObjCParamType>\n { + codifyLines(yyscanner,yytext); + } +<ReadInclude>[^\n\"\>]+/(">"|"\"") { + //FileInfo *f; + bool ambig; + bool found=FALSE; + //QCString absPath = yytext; + //if (yyextra->sourceFileDef && QDir::isRelativePath(absPath)) + //{ + // absPath = QDir::cleanDirPath(yyextra->sourceFileDef->getPath()+"/"+absPath); + //} + + FileDef *fd=findFileDef(Doxygen::inputNameDict,yytext,ambig); + //printf("looking for include %s -> %s fd=%p\n",yytext,absPath.data(),fd); + if (fd && fd->isLinkable()) + { + if (ambig) // multiple input files match the name + { + //printf("===== yes %s is ambiguous\n",yytext); + QCString name = QDir::cleanDirPath(yytext).utf8(); + if (!name.isEmpty() && yyextra->sourceFileDef) + { + FileName *fn = Doxygen::inputNameDict->find(name); + if (fn) + { + FileNameIterator fni(*fn); + // for each include name + for (fni.toFirst();!found && (fd=fni.current());++fni) + { + // see if this source file actually includes the file + found = yyextra->sourceFileDef->isIncluded(fd->absFilePath()); + //printf(" include file %s found=%d\n",fd->absFilePath().data(),found); + } + } + } + } + else // not ambiguous + { + found = TRUE; + } + } + //printf(" include file %s found=%d\n",fd ? fd->absFilePath().data() : "<none>",found); + if (found) + { + writeMultiLineCodeLink(yyscanner,*yyextra->code,fd,yytext); + } + else + { + yyextra->code->codify(yytext); + } + char c=yyinput(yyscanner); + QCString text; + text+=c; + yyextra->code->codify(text); + endFontClass(yyscanner); + BEGIN( Body ); + } +<Body,Bases>^[ \t]*"#" { + startFontClass(yyscanner,"preprocessor"); + yyextra->lastSkipCppContext = YY_START; + yyextra->code->codify(yytext); + BEGIN( SkipCPP ) ; + } +<SkipCPP>. { + yyextra->code->codify(yytext); + } +<SkipCPP>[^\n\/\\]+ { + yyextra->code->codify(yytext); + } +<SkipCPP>\\[\r]?\n { + codifyLines(yyscanner,yytext); + } +<SkipCPP>"//" { + yyextra->code->codify(yytext); + } +<Body,FuncCall>"{" { + yyextra->theVarContext.pushScope(); + + DBG_CTX((stderr,"** scope stack push INNERBLOCK\n")); + yyextra->scopeStack.push(INNERBLOCK); + + if (yyextra->searchingForBody) + { + yyextra->searchingForBody=FALSE; + yyextra->insideBody=TRUE; + } + yyextra->code->codify(yytext); + if (yyextra->insideBody) + { + yyextra->bodyCurlyCount++; + } + yyextra->type.resize(0); + yyextra->name.resize(0); + BEGIN( Body ); + } +<Body,FuncCall,MemberCall,MemberCall2>"}" { + yyextra->theVarContext.popScope(); + yyextra->type.resize(0); + yyextra->name.resize(0); + + int *scope = yyextra->scopeStack.pop(); + DBG_CTX((stderr,"** scope stack pop SCOPEBLOCK=%d\n",scope==SCOPEBLOCK)); + if (scope==SCOPEBLOCK || scope==CLASSBLOCK) + { + popScope(yyscanner); + } + + yyextra->code->codify(yytext); + + DBG_CTX((stderr,"yyextra->bodyCurlyCount=%d\n",yyextra->bodyCurlyCount)); + if (--yyextra->bodyCurlyCount<=0) + { + yyextra->insideBody=FALSE; + yyextra->currentMemberDef=0; + if (yyextra->currentDefinition) + yyextra->currentDefinition=yyextra->currentDefinition->getOuterScope(); + } + BEGIN(Body); + } +<Body,ClassVar>"@end" { + //printf("End of objc scope fd=%s\n",yyextra->sourceFileDef->name().data()); + if (yyextra->sourceFileDef) + { + FileDef *fd=yyextra->sourceFileDef; + yyextra->insideObjC = fd->name().lower().right(2)==".m" || + fd->name().lower().right(3)==".mm"; + //printf("insideObjC=%d\n",yyextra->insideObjC); + } + else + { + yyextra->insideObjC = FALSE; + } + if (yyextra->insideBody) + { + yyextra->theVarContext.popScope(); + + int *scope = yyextra->scopeStack.pop(); + DBG_CTX((stderr,"** scope stack pop SCOPEBLOCK=%d\n",scope==SCOPEBLOCK)); + if (scope==SCOPEBLOCK || scope==CLASSBLOCK) + { + popScope(yyscanner); + } + yyextra->insideBody=FALSE; + } + + startFontClass(yyscanner,"keyword"); + yyextra->code->codify(yytext); + endFontClass(yyscanner); + + yyextra->currentMemberDef=0; + if (yyextra->currentDefinition) + yyextra->currentDefinition=yyextra->currentDefinition->getOuterScope(); + BEGIN(Body); + } +<ClassName,ClassVar>";" { + yyextra->code->codify(yytext); + yyextra->searchingForBody=FALSE; + BEGIN( Body ); + } +<ClassName,ClassVar>[*&^%]+ { + yyextra->type=yyextra->curClassName.copy(); + yyextra->name.resize(0); + yyextra->code->codify(yytext); + BEGIN( Body ); // variable of type struct * + } +<ClassName>"__declspec"{B}*"("{B}*{ID}{B}*")" { + startFontClass(yyscanner,"keyword"); + yyextra->code->codify(yytext); + endFontClass(yyscanner); + } +<ClassName>{ID}("."{ID})* | +<ClassName>{ID}("::"{ID})* { + if (yyextra->lang==SrcLangExt_CSharp) + yyextra->curClassName=substitute(yytext,".","::"); + else + yyextra->curClassName=yytext; + addType(yyscanner); + if (yyextra->curClassName=="alignas") + { + startFontClass(yyscanner,"keyword"); + yyextra->code->codify(yytext); + endFontClass(yyscanner); + BEGIN( AlignAs ); + } + else + { + generateClassOrGlobalLink(yyscanner,*yyextra->code,yytext); + BEGIN( ClassVar ); + } + } +<AlignAs>"(" { + yyextra->bracketCount=1; + yyextra->code->codify(yytext); + BEGIN( AlignAsEnd ); + } +<AlignAs>\n { yyextra->yyLineNr++; + codifyLines(yyscanner,yytext); + } +<AlignAs>. { yyextra->code->codify(yytext); } +<AlignAsEnd>"(" { yyextra->code->codify(yytext); + yyextra->bracketCount++; + } +<AlignAsEnd>")" { + yyextra->code->codify(yytext); + if (--yyextra->bracketCount<=0) + { + BEGIN(ClassName); + } + } +<AlignAsEnd>\n { yyextra->yyLineNr++; + codifyLines(yyscanner,yytext); + } +<AlignAsEnd>. { yyextra->code->codify(yytext); } +<ClassName>{ID}("\\"{ID})* { // PHP namespace + yyextra->curClassName=substitute(yytext,"\\","::"); + yyextra->scopeStack.push(CLASSBLOCK); + pushScope(yyscanner,yyextra->curClassName); + addType(yyscanner); + generateClassOrGlobalLink(yyscanner,*yyextra->code,yytext); + BEGIN( ClassVar ); + } +<ClassName>{ID}{B}*"("{ID}")" { // Obj-C category + yyextra->curClassName=removeRedundantWhiteSpace(yytext); + yyextra->scopeStack.push(CLASSBLOCK); + pushScope(yyscanner,yyextra->curClassName); + addType(yyscanner); + generateClassOrGlobalLink(yyscanner,*yyextra->code,yytext); + BEGIN( ClassVar ); + } +<PackageName>{ID}("."{ID})* { + yyextra->curClassName=substitute(yytext,".","::"); + //printf("found package: %s\n",yyextra->curClassName.data()); + addType(yyscanner); + codifyLines(yyscanner,yytext); + } +<ClassVar>"=" { + unput(*yytext); + BEGIN( Body ); + } +<ClassVar>("extends"|"implements") { // Java, Slice + startFontClass(yyscanner,"keyword"); + codifyLines(yyscanner,yytext); + endFontClass(yyscanner); + yyextra->curClassBases.clear(); + BEGIN( Bases ); + } +<ClassVar>("sealed"|"abstract")/{BN}*(":"|"{") { + DBG_CTX((stderr,"***** C++/CLI modifier %s on yyextra->curClassName=%s\n",yytext,yyextra->curClassName.data())); + startFontClass(yyscanner,"keyword"); + codifyLines(yyscanner,yytext); + endFontClass(yyscanner); + BEGIN( CppCliTypeModifierFollowup ); + } +<ClassVar>{ID} { + yyextra->type = yyextra->curClassName.copy(); + yyextra->name = yytext; + if (yyextra->insideBody) + { + yyextra->theVarContext.addVariable(yyscanner,yyextra->type,yyextra->name); + } + generateClassOrGlobalLink(yyscanner,*yyextra->code,yytext); + } +<ClassName,ClassVar,CppCliTypeModifierFollowup>{B}*":"{B}* { + codifyLines(yyscanner,yytext); + yyextra->curClassBases.clear(); + BEGIN( Bases ); + } +<PackageName>[ \t]*";" | +<Bases>^{B}*/"@"{ID} | // Objective-C interface +<Bases,ClassName,ClassVar,CppCliTypeModifierFollowup>{B}*"{"{B}* { + yyextra->theVarContext.pushScope(); + yyextra->code->codify(yytext); + if (YY_START==ClassVar && yyextra->curClassName.isEmpty()) + { + yyextra->curClassName = yyextra->name.copy(); + } + if (yyextra->searchingForBody) + { + yyextra->searchingForBody=FALSE; + yyextra->insideBody=TRUE; + } + if (yyextra->insideBody) yyextra->bodyCurlyCount++; + if (!yyextra->curClassName.isEmpty()) // valid class name + { + DBG_CTX((stderr,"** scope stack push CLASSBLOCK\n")); + yyextra->scopeStack.push(CLASSBLOCK); + pushScope(yyscanner,yyextra->curClassName); + DBG_CTX((stderr,"***** yyextra->curClassName=%s\n",yyextra->curClassName.data())); + if (getResolvedClass(yyextra->currentDefinition,yyextra->sourceFileDef,yyextra->curClassName)==0) + { + DBG_CTX((stderr,"Adding new class %s\n",yyextra->curClassName.data())); + ClassDef *ncd=createClassDef("<code>",1,1, + yyextra->curClassName,ClassDef::Class,0,0,FALSE); + yyextra->codeClassSDict->append(yyextra->curClassName,ncd); + // insert base classes. + char *s=yyextra->curClassBases.first(); + while (s) + { + const ClassDef *bcd=yyextra->codeClassSDict->find(s); + if (bcd==0) bcd=getResolvedClass(yyextra->currentDefinition,yyextra->sourceFileDef,s); + if (bcd && bcd!=ncd) + { + ncd->insertBaseClass(const_cast<ClassDef*>(bcd),s,Public,Normal); + } + s=yyextra->curClassBases.next(); + } + } + //printf("yyextra->codeClassList.count()=%d\n",yyextra->codeClassList.count()); + } + else // not a class name -> assume inner block + { + DBG_CTX((stderr,"** scope stack push INNERBLOCK\n")); + yyextra->scopeStack.push(INNERBLOCK); + } + yyextra->curClassName.resize(0); + yyextra->curClassBases.clear(); + BEGIN( Body ); + } +<Bases>"virtual"|"public"|"protected"|"private"|"@public"|"@private"|"@protected" { + startFontClass(yyscanner,"keyword"); + yyextra->code->codify(yytext); + endFontClass(yyscanner); + } +<Bases>{SEP}?({ID}{SEP})*{ID} { + DBG_CTX((stderr,"%s:addBase(%s)\n",yyextra->curClassName.data(),yytext)); + yyextra->curClassBases.inSort(yytext); + generateClassOrGlobalLink(yyscanner,*yyextra->code,yytext); + } +<Bases>"<" { + yyextra->code->codify(yytext); + if (!yyextra->insideObjC) + { + yyextra->sharpCount=1; + BEGIN ( SkipSharp ); + } + else + { + yyextra->insideProtocolList=TRUE; + } + } +<Bases>">" { + yyextra->code->codify(yytext); + yyextra->insideProtocolList=FALSE; + } +<SkipSharp>"<" { + yyextra->code->codify(yytext); + ++yyextra->sharpCount; + } +<SkipSharp>">" { + yyextra->code->codify(yytext); + if (--yyextra->sharpCount<=0) + BEGIN ( Bases ); + } +<SkipSharp>"\"" { + yyextra->code->codify(yytext); + yyextra->lastStringContext=YY_START; + BEGIN(SkipString); + } +<SkipSharp>"\'" { + yyextra->code->codify(yytext); + yyextra->lastStringContext=YY_START; + BEGIN(SkipStringS); + } +<Bases>"(" { + yyextra->code->codify(yytext); + yyextra->sharpCount=1; + BEGIN ( SkipSharp ); + } +<SkipSharp>"(" { + yyextra->code->codify(yytext); + ++yyextra->sharpCount; + } +<SkipSharp>")" { + yyextra->code->codify(yytext); + if (--yyextra->sharpCount<=0) + BEGIN ( Bases ); + } + + +<Bases>"," { + yyextra->code->codify(yytext); + } + + +<Body>{SCOPEPREFIX}?"operator"{B}*"()"{B}*/"(" { + addType(yyscanner); + generateFunctionLink(yyscanner,*yyextra->code,yytext); + yyextra->bracketCount=0; + yyextra->args.resize(0); + yyextra->name+=yytext; + BEGIN( FuncCall ); + } +<Body>{SCOPEPREFIX}?"operator"/"(" { + addType(yyscanner); + generateFunctionLink(yyscanner,*yyextra->code,yytext); + yyextra->bracketCount=0; + yyextra->args.resize(0); + yyextra->name+=yytext; + BEGIN( FuncCall ); + } +<Body>{SCOPEPREFIX}?"operator"[^a-z_A-Z0-9\(\n]+/"(" { + addType(yyscanner); + generateFunctionLink(yyscanner,*yyextra->code,yytext); + yyextra->bracketCount=0; + yyextra->args.resize(0); + yyextra->name+=yytext; + BEGIN( FuncCall ); + } +<Body,TemplDecl>("template"|"generic")/([^a-zA-Z0-9]) { + startFontClass(yyscanner,"keyword"); + codifyLines(yyscanner,yytext); + endFontClass(yyscanner); + yyextra->insideTemplate=TRUE; + yyextra->sharpCount=0; + } +<Body>"using"{BN}+"namespace"{BN}+ { + startFontClass(yyscanner,"keyword"); + codifyLines(yyscanner,yytext); + endFontClass(yyscanner); + BEGIN(UsingName); + } +<UsingName>{ID}("::"{ID})* { addUsingDirective(yyscanner,yytext); + generateClassOrGlobalLink(yyscanner,*yyextra->code,yytext); + DBG_CTX((stderr,"** scope stack push CLASSBLOCK\n")); + yyextra->scopeStack.push(CLASSBLOCK); + pushScope(yyscanner,yytext); + BEGIN(Body); + } +<UsingName>\n { codifyLines(yyscanner,yytext); BEGIN(Body); } +<UsingName>. { codifyLines(yyscanner,yytext); BEGIN(Body); } +<Body,FuncCall>"$"?"this"("->"|".") { yyextra->code->codify(yytext); // this-> for C++, this. for C# + yyextra->prefixed_with_this_keyword = TRUE; + } +<Body>{KEYWORD}/([^a-z_A-Z0-9]) { + if (yyextra->lang==SrcLangExt_Java && qstrcmp("internal",yytext) ==0) REJECT; + if (skipLanguageSpecificKeyword(yyscanner,yytext)) REJECT; + startFontClass(yyscanner,"keyword"); + codifyLines(yyscanner,yytext); + if (QCString(yytext)=="typedef") + { + addType(yyscanner); + yyextra->name+=yytext; + } + endFontClass(yyscanner); + } +<Body>{KEYWORD}/{B}* { + if (skipLanguageSpecificKeyword(yyscanner,yytext)) REJECT; + startFontClass(yyscanner,"keyword"); + codifyLines(yyscanner,yytext); + endFontClass(yyscanner); + } +<Body>{KEYWORD}/{BN}*"(" { + if (skipLanguageSpecificKeyword(yyscanner,yytext)) REJECT; + startFontClass(yyscanner,"keyword"); + codifyLines(yyscanner,yytext); + endFontClass(yyscanner); + yyextra->name.resize(0);yyextra->type.resize(0); + } +<FuncCall>"in"/{BN}* { + if (!yyextra->inForEachExpression) REJECT; + startFontClass(yyscanner,"keywordflow"); + codifyLines(yyscanner,yytext); + endFontClass(yyscanner); + // insert the variable in the parent scope, see bug 546158 + yyextra->theVarContext.popScope(); + yyextra->theVarContext.addVariable(yyscanner,yyextra->parmType,yyextra->parmName); + yyextra->theVarContext.pushScope(); + yyextra->name.resize(0);yyextra->type.resize(0); + } +<Body>{FLOWKW}/{BN}*"(" { + startFontClass(yyscanner,"keywordflow"); + codifyLines(yyscanner,yytext); + endFontClass(yyscanner); + yyextra->name.resize(0);yyextra->type.resize(0); + yyextra->inForEachExpression = (qstrcmp(yytext,"for each")==0 || qstrcmp(yytext, "foreach")==0); + BEGIN(FuncCall); + } +<Body>{FLOWCONDITION}/{BN}*"(" { + if (yyextra->currentMemberDef && yyextra->currentMemberDef->isFunction()) + { + yyextra->currentMemberDef->incrementFlowKeyWordCount(); + } + startFontClass(yyscanner,"keywordflow"); + codifyLines(yyscanner,yytext); + endFontClass(yyscanner); + yyextra->name.resize(0);yyextra->type.resize(0); + yyextra->inForEachExpression = (strcmp(yytext,"for each")==0 || strcmp(yytext, "foreach")==0); + BEGIN(FuncCall); + } +<Body>{FLOWKW}/([^a-z_A-Z0-9]) { + startFontClass(yyscanner,"keywordflow"); + codifyLines(yyscanner,yytext); + endFontClass(yyscanner); + if (yyextra->inFunctionTryBlock && (qstrcmp(yytext,"catch")==0 || qstrcmp(yytext,"finally")==0)) + { + yyextra->inFunctionTryBlock=FALSE; + } + } +<Body>{FLOWCONDITION}/([^a-z_A-Z0-9]) { + if (yyextra->currentMemberDef && yyextra->currentMemberDef->isFunction()) + { + yyextra->currentMemberDef->incrementFlowKeyWordCount(); + } + startFontClass(yyscanner,"keywordflow"); + codifyLines(yyscanner,yytext); + endFontClass(yyscanner); + if (yyextra->inFunctionTryBlock && (strcmp(yytext,"catch")==0 || strcmp(yytext,"finally")==0)) + { + yyextra->inFunctionTryBlock=FALSE; + } + } +<Body>{FLOWKW}/{B}* { + startFontClass(yyscanner,"keywordflow"); + codifyLines(yyscanner,yytext); + endFontClass(yyscanner); + } +<Body>{FLOWCONDITION}/{B}* { + if (yyextra->currentMemberDef && yyextra->currentMemberDef->isFunction()) + { + yyextra->currentMemberDef->incrementFlowKeyWordCount(); + } + startFontClass(yyscanner,"keywordflow"); + codifyLines(yyscanner,yytext); + endFontClass(yyscanner); + } +<Body>"*"{B}*")" { // end of cast? + yyextra->code->codify(yytext); + yyextra->theCallContext.popScope(yyextra->name, yyextra->type); + yyextra->bracketCount--; + yyextra->parmType = yyextra->name; + BEGIN(FuncCall); + } +<Body>[\\|\)\+\-\/\%\~\!] { + yyextra->code->codify(yytext); + yyextra->name.resize(0);yyextra->type.resize(0); + if (*yytext==')') + { + yyextra->theCallContext.popScope(yyextra->name, yyextra->type); + yyextra->bracketCount--; + BEGIN(FuncCall); + } + } +<Body,TemplDecl,ObjCMethod>{TYPEKW}/{B}* { + startFontClass(yyscanner,"keywordtype"); + yyextra->code->codify(yytext); + endFontClass(yyscanner); + addType(yyscanner); + yyextra->name+=yytext; + } +<Body,TemplDecl,ObjCMethod>{TYPEKWSL}/{B}* { + if (yyextra->lang!=SrcLangExt_Slice) + { + REJECT; + } + else + { + startFontClass(yyscanner,"keywordtype"); + yyextra->code->codify(yytext); + endFontClass(yyscanner); + addType(yyscanner); + yyextra->name+=yytext; + } + } +<Body>"generic"/{B}*"<"[^\n\/\-\.\{\"\>]*">"{B}* { + startFontClass(yyscanner,"keyword"); + yyextra->code->codify(yytext); + endFontClass(yyscanner); + yyextra->sharpCount=0; + BEGIN(TemplDecl); + } +<Body>"template"/{B}*"<"[^\n\/\-\.\{\"\>]*">"{B}* { // template<...> + startFontClass(yyscanner,"keyword"); + yyextra->code->codify(yytext); + endFontClass(yyscanner); + yyextra->sharpCount=0; + BEGIN(TemplDecl); + } +<TemplDecl>"class"|"typename" { + startFontClass(yyscanner,"keyword"); + codifyLines(yyscanner,yytext); + endFontClass(yyscanner); + } +<TemplDecl>"<" { + yyextra->code->codify(yytext); + yyextra->sharpCount++; + } +<TemplDecl>">" { + yyextra->code->codify(yytext); + yyextra->sharpCount--; + if (yyextra->sharpCount<=0) + { + BEGIN(Body); + } + } +<TemplCast>">" { + startFontClass(yyscanner,"keyword"); + codifyLines(yyscanner,yytext); + endFontClass(yyscanner); + BEGIN( yyextra->lastTemplCastContext ); + } +<TemplCast>{ID}("::"{ID})* { + generateClassOrGlobalLink(yyscanner,*yyextra->code,yytext); + } +<TemplCast>("const"|"volatile"){B}* { + startFontClass(yyscanner,"keyword"); + codifyLines(yyscanner,yytext); + endFontClass(yyscanner); + } +<TemplCast>[*^]* { + codifyLines(yyscanner,yytext); + } +<Body,MemberCall2,FuncCall>{CASTKW}{B}*"<" { // static_cast<T>( + startFontClass(yyscanner,"keyword"); + codifyLines(yyscanner,yytext); + endFontClass(yyscanner); + yyextra->lastTemplCastContext = YY_START; + BEGIN(TemplCast); + } +<Body>"$this->"{SCOPENAME}/{BN}*[;,)\]] { // PHP member variable + addType(yyscanner); + generatePHPVariableLink(yyscanner,*yyextra->code,yytext); + yyextra->name+=yytext+7; + } +<Body,TemplCast>{SCOPENAME}{B}*"<"[^\n\/\-\.\{\"\>\(]*">"("::"{ID})*/{B}* { // A<T> *pt; + if (isCastKeyword(yytext) && YY_START==Body) + { + REJECT; + } + addType(yyscanner); + generateClassOrGlobalLink(yyscanner,*yyextra->code,yytext); + yyextra->name+=yytext; + } +<Body>{SCOPENAME}/{BN}*[:;,)\]] { // "int var;" or "var, var2" or "debug(f) macro" , or int var : 5; + addType(yyscanner); + // changed this to generateFunctionLink, see bug 624514 + //generateClassOrGlobalLink(yyscanner,*yyextra->code,yytext,FALSE,TRUE); + generateFunctionLink(yyscanner,*yyextra->code,yytext); + yyextra->name+=yytext; + } +<Body>{SCOPENAME}/{B}* { // p->func() + addType(yyscanner); + generateClassOrGlobalLink(yyscanner,*yyextra->code,yytext); + yyextra->name+=yytext; + } +<Body>"("{B}*("*"{B}*)+{SCOPENAME}*{B}*")"/{B}* { // (*p)->func() but not "if (p) ..." + yyextra->code->codify(yytext); + int s=0;while (s<(int)yyleng && !isId(yytext[s])) s++; + int e=(int)yyleng-1;while (e>=0 && !isId(yytext[e])) e--; + QCString varname = ((QCString)yytext).mid(s,e-s+1); + addType(yyscanner); + yyextra->name=varname; + } +<Body>{SCOPETNAME}{B}*"<"[^\n\/\-\.\{\"\>]*">"/{BN}*"(" | +<Body>{SCOPETNAME}/{BN}*"(" { // a() or c::a() or t<A,B>::a() or A\B\foo() + if (isCastKeyword(yytext)) + { + REJECT; + } + addType(yyscanner); + generateFunctionLink(yyscanner,*yyextra->code,yytext); + yyextra->bracketCount=0; + yyextra->args.resize(0); + yyextra->name+=yytext; + BEGIN( FuncCall ); + } +<FuncCall,Body,MemberCall,MemberCall2,SkipInits,InlineInit>{RAWBEGIN} { + QCString text=yytext; + int i=text.find('R'); + yyextra->code->codify(text.left(i+1)); + startFontClass(yyscanner,"stringliteral"); + yyextra->code->codify(yytext+i+1); + yyextra->lastStringContext=YY_START; + yyextra->inForEachExpression = FALSE; + yyextra->delimiter = yytext+i+2; + yyextra->delimiter=yyextra->delimiter.left(yyextra->delimiter.length()-1); + BEGIN( RawString ); + } +<FuncCall,Body,MemberCall,MemberCall2,SkipInits,InlineInit>\" { + startFontClass(yyscanner,"stringliteral"); + yyextra->code->codify(yytext); + yyextra->lastStringContext=YY_START; + yyextra->inForEachExpression = FALSE; + BEGIN( SkipString ); + } +<FuncCall,Body,MemberCall,MemberCall2,SkipInits,InlineInit>\' { + startFontClass(yyscanner,"stringliteral"); + yyextra->code->codify(yytext); + yyextra->lastStringContext=YY_START; + yyextra->inForEachExpression = FALSE; + BEGIN( SkipStringS ); + } +<SkipString>[^\"\\\r\n]* { + yyextra->code->codify(yytext); + } +<SkipStringS>[^\'\\\r\n]* { + yyextra->code->codify(yytext); + } +<SkipString,SkipStringS>"//"|"/*" { + yyextra->code->codify(yytext); + } +<SkipString>@?\" { + yyextra->code->codify(yytext); + endFontClass(yyscanner); + BEGIN( yyextra->lastStringContext ); + } +<SkipStringS>\' { + yyextra->code->codify(yytext); + endFontClass(yyscanner); + BEGIN( yyextra->lastStringContext ); + } +<SkipString,SkipStringS>\\. { + yyextra->code->codify(yytext); + } +<RawString>{RAWEND} { + yyextra->code->codify(yytext); + QCString delimiter = yytext+1; + delimiter=delimiter.left(delimiter.length()-1); + if (delimiter==yyextra->delimiter) + { + BEGIN( yyextra->lastStringContext ); + } + } +<RawString>[^)\n]+ { yyextra->code->codify(yytext); } +<RawString>. { yyextra->code->codify(yytext); } +<RawString>\n { codifyLines(yyscanner,yytext); } +<SkipVerbString>[^"\n]+ { + yyextra->code->codify(yytext); + } +<SkipVerbString>\"\" { // escaped quote + yyextra->code->codify(yytext); + } +<SkipVerbString>\" { // end of string + yyextra->code->codify(yytext); + endFontClass(yyscanner); + BEGIN( yyextra->lastVerbStringContext ); + } +<SkipVerbString>. { + yyextra->code->codify(yytext); + } +<SkipVerbString>\n { + codifyLines(yyscanner,yytext); + } +<Body>":" { + yyextra->code->codify(yytext); + yyextra->name.resize(0);yyextra->type.resize(0); + } +<Body>"<" { + if (yyextra->insideTemplate) + { + yyextra->sharpCount++; + } + yyextra->code->codify(yytext); + } +<Body>">" { + if (yyextra->insideTemplate) + { + if (--yyextra->sharpCount<=0) + { + yyextra->insideTemplate=FALSE; + } + } + yyextra->code->codify(yytext); + } +<Body,MemberCall,MemberCall2,FuncCall>"'"((\\0[Xx0-9]+)|(\\.)|(.))"'" { + startFontClass(yyscanner,"charliteral"); + yyextra->code->codify(yytext); + endFontClass(yyscanner); + } +<Body>"."|"->" { + if (yytext[0]=='-') // -> could be overloaded + { + updateCallContextForSmartPointer(yyscanner); + } + yyextra->code->codify(yytext); + yyextra->memCallContext = YY_START; + BEGIN( MemberCall ); + } +<MemberCall>{SCOPETNAME}/{BN}*"(" { + if (yyextra->theCallContext.getScope()) + { + if (!generateClassMemberLink(yyscanner,*yyextra->code,yyextra->theCallContext.getScope(),yytext)) + { + yyextra->code->codify(yytext); + addToSearchIndex(yyscanner,yytext); + } + yyextra->name.resize(0); + } + else + { + yyextra->code->codify(yytext); + addToSearchIndex(yyscanner,yytext); + yyextra->name.resize(0); + } + yyextra->type.resize(0); + if (yyextra->memCallContext==Body) + { + BEGIN(FuncCall); + } + else + { + BEGIN(yyextra->memCallContext); + } + } +<MemberCall>{SCOPENAME}/{B}* { + if (yyextra->theCallContext.getScope()) + { + DBG_CTX((stderr,"yyextra->theCallContext.getClass()=%p\n",yyextra->theCallContext.getScope())); + if (!generateClassMemberLink(yyscanner,*yyextra->code,yyextra->theCallContext.getScope(),yytext)) + { + yyextra->code->codify(yytext); + addToSearchIndex(yyscanner,yytext); + } + yyextra->name.resize(0); + } + else + { + DBG_CTX((stderr,"no class context!\n")); + yyextra->code->codify(yytext); + addToSearchIndex(yyscanner,yytext); + yyextra->name.resize(0); + } + yyextra->type.resize(0); + BEGIN(yyextra->memCallContext); + } +<Body>[,=;\[] { + if (yyextra->insideObjC && *yytext=='[') + { + //printf("Found start of ObjC call!\n"); + // start of a method call + yyextra->contextDict.setAutoDelete(TRUE); + yyextra->nameDict.setAutoDelete(TRUE); + yyextra->objectDict.setAutoDelete(TRUE); + yyextra->wordDict.setAutoDelete(TRUE); + yyextra->commentDict.setAutoDelete(TRUE); + yyextra->contextDict.clear(); + yyextra->nameDict.clear(); + yyextra->objectDict.clear(); + yyextra->wordDict.clear(); + yyextra->commentDict.clear(); + yyextra->currentCtxId = 0; + yyextra->currentNameId = 0; + yyextra->currentObjId = 0; + yyextra->currentCtx = 0; + yyextra->braceCount = 0; + unput('['); + BEGIN(ObjCCall); + } + else + { + yyextra->code->codify(yytext); + yyextra->saveName = yyextra->name.copy(); + yyextra->saveType = yyextra->type.copy(); + if (*yytext!='[' && !yyextra->type.isEmpty()) + { + //printf("yyextra->scopeStack.bottom()=%p\n",yyextra->scopeStack.bottom()); + //if (yyextra->scopeStack.top()!=CLASSBLOCK) // commented out for bug731363 + { + //printf("AddVariable: '%s' '%s' context=%d\n", + // yyextra->type.data(),yyextra->name.data(),yyextra->theVarContext.count()); + yyextra->theVarContext.addVariable(yyscanner,yyextra->type,yyextra->name); + } + yyextra->name.resize(0); + } + if (*yytext==';' || *yytext=='=') + { + yyextra->type.resize(0); + yyextra->name.resize(0); + } + else if (*yytext=='[') + { + yyextra->theCallContext.pushScope(yyextra->name, yyextra->type); + } + yyextra->args.resize(0); + yyextra->parmType.resize(0); + yyextra->parmName.resize(0); + } + } + /* +<ObjCMemberCall>{ID} { + if (qstrcmp(yytext,"self")==0 || qstrcmp(yytext,"super")==0) + { + // TODO: get proper base class for "super" + yyextra->theCallContext.setClass(getClass(yyextra->curClassName)); + startFontClass(yyscanner,"keyword"); + yyextra->code->codify(yytext); + endFontClass(yyscanner); + } + else + { + generateClassOrGlobalLink(yyscanner,*yyextra->code,yytext); + } + yyextra->name.resize(0); + BEGIN(ObjCMemberCall2); + } +<ObjCMemberCall>"[" { + yyextra->code->codify(yytext); + yyextra->theCallContext.pushScope(yyscanner,yyextra->name, yyextra->type); + } +<ObjCMemberCall2>{ID}":"? { + yyextra->name+=yytext; + if (yyextra->theCallContext.getClass()) + { + //printf("Calling method %s\n",yyextra->name.data()); + if (!generateClassMemberLink(yyscanner,*yyextra->code,yyextra->theCallContext.getClass(),yyextra->name)) + { + yyextra->code->codify(yytext); + addToSearchIndex(yyscanner,yyextra->name); + } + } + else + { + yyextra->code->codify(yytext); + addToSearchIndex(yyscanner,yyextra->name); + } + yyextra->name.resize(0); + BEGIN(ObjCMemberCall3); + } +<ObjCMemberCall2,ObjCMemberCall3>"]" { + yyextra->theCallContext.popScope(yyextra->name, yyextra->type); + yyextra->code->codify(yytext); + BEGIN(Body); + } + */ +<ObjCCall,ObjCMName>"["|"{" { + saveObjCContext(yyscanner); + yyextra->currentCtx->format+=*yytext; + BEGIN(ObjCCall); + //printf("open\n"); + } +<ObjCCall,ObjCMName>"]"|"}" { + yyextra->currentCtx->format+=*yytext; + restoreObjCContext(yyscanner); + BEGIN(ObjCMName); + if (yyextra->currentCtx==0) + { + // end of call + writeObjCMethodCall(yyscanner,yyextra->contextDict.find(0)); + BEGIN(Body); + } + //printf("close\n"); + } +<ObjCCall,ObjCMName>"//".* { + yyextra->currentCtx->format+=escapeComment(yyscanner,yytext); + } +<ObjCCall,ObjCMName>"/*" { + yyextra->lastObjCCallContext = YY_START; + yyextra->currentCtx->comment=yytext; + BEGIN(ObjCCallComment); + } +<ObjCCallComment>"*/" { + yyextra->currentCtx->comment+=yytext; + yyextra->currentCtx->format+=escapeComment(yyscanner,yyextra->currentCtx->comment); + BEGIN(yyextra->lastObjCCallContext); + } +<ObjCCallComment>[^*\n]+ { yyextra->currentCtx->comment+=yytext; } +<ObjCCallComment>"//"|"/*" { yyextra->currentCtx->comment+=yytext; } +<ObjCCallComment>\n { yyextra->currentCtx->comment+=*yytext; } +<ObjCCallComment>. { yyextra->currentCtx->comment+=*yytext; } +<ObjCCall>{ID} { + yyextra->currentCtx->format+=escapeObject(yyscanner,yytext); + if (yyextra->braceCount==0) + { + yyextra->currentCtx->objectTypeOrName=yytext; + //printf("new type=%s\n",yyextra->currentCtx->objectTypeOrName.data()); + BEGIN(ObjCMName); + } + } +<ObjCMName>{ID}/{BN}*"]" { + if (yyextra->braceCount==0 && + yyextra->currentCtx->methodName.isEmpty()) + { + yyextra->currentCtx->methodName=yytext; + yyextra->currentCtx->format+=escapeName(yyscanner,yytext); + } + else + { + yyextra->currentCtx->format+=escapeWord(yyscanner,yytext); + } + } +<ObjCMName>{ID}/{BN}*":" { + if (yyextra->braceCount==0) + { + yyextra->currentCtx->methodName+=yytext; + yyextra->currentCtx->methodName+=":"; + } + yyextra->currentCtx->format+=escapeName(yyscanner,yytext); + } +<ObjCSkipStr>[^\n\"$\\]* { yyextra->currentCtx->format+=yytext; } +<ObjCSkipStr>\\. { yyextra->currentCtx->format+=yytext; } +<ObjCSkipStr>"\"" { yyextra->currentCtx->format+=yytext; + BEGIN(yyextra->lastStringContext); + } +<ObjCCall,ObjCMName>{CHARLIT} { yyextra->currentCtx->format+=yytext; } +<ObjCCall,ObjCMName>"@"?"\"" { yyextra->currentCtx->format+=yytext; + yyextra->lastStringContext=YY_START; + BEGIN(ObjCSkipStr); + } +<ObjCCall,ObjCMName,ObjCSkipStr>"$" { yyextra->currentCtx->format+="$$"; } +<ObjCCall,ObjCMName>"(" { yyextra->currentCtx->format+=*yytext; yyextra->braceCount++; } +<ObjCCall,ObjCMName>")" { yyextra->currentCtx->format+=*yytext; yyextra->braceCount--; } +<ObjCSkipStr>"@"/"\"" { // needed to prevent matching the global rule (for C#) + yyextra->currentCtx->format+=yytext; + } +<ObjCCall,ObjCMName,ObjCSkipStr>{ID} { yyextra->currentCtx->format+=escapeWord(yyscanner,yytext); } +<ObjCCall,ObjCMName,ObjCSkipStr>. { yyextra->currentCtx->format+=*yytext; } +<ObjCCall,ObjCMName,ObjCSkipStr>\n { yyextra->currentCtx->format+=*yytext; } + +<Body>"]" { + yyextra->theCallContext.popScope(yyextra->name, yyextra->type); + yyextra->code->codify(yytext); + // TODO: nested arrays like: a[b[0]->func()]->func() + yyextra->name = yyextra->saveName.copy(); + yyextra->type = yyextra->saveType.copy(); + } +<Body>[0-9]+ { + yyextra->code->codify(yytext); + } +<Body>[0-9]+[xX][0-9A-Fa-f]+ { + yyextra->code->codify(yytext); + } +<MemberCall2,FuncCall>{KEYWORD}/([^a-z_A-Z0-9]) { + //addParmType(yyscanner); + //yyextra->parmName=yytext; + if (skipLanguageSpecificKeyword(yyscanner,yytext)) REJECT; + startFontClass(yyscanner,"keyword"); + yyextra->code->codify(yytext); + endFontClass(yyscanner); + } +<MemberCall2,FuncCall,OldStyleArgs,TemplCast>{TYPEKW}/([^a-z_A-Z0-9]) { + addParmType(yyscanner); + yyextra->parmName=yytext; + startFontClass(yyscanner,"keywordtype"); + yyextra->code->codify(yytext); + endFontClass(yyscanner); + } +<MemberCall2,FuncCall,OldStyleArgs,TemplCast>{TYPEKWSL}/([^a-z_A-Z0-9]) { + if (yyextra->lang!=SrcLangExt_Slice) + { + REJECT; + } + else + { + addParmType(yyscanner); + yyextra->parmName=yytext; + startFontClass(yyscanner,"keywordtype"); + yyextra->code->codify(yytext); + endFontClass(yyscanner); + } + } +<MemberCall2,FuncCall>{FLOWKW}/([^a-z_A-Z0-9]) { + addParmType(yyscanner); + yyextra->parmName=yytext; + startFontClass(yyscanner,"keywordflow"); + yyextra->code->codify(yytext); + endFontClass(yyscanner); + } +<MemberCall2,FuncCall>{FLOWCONDITION}/([^a-z_A-Z0-9]) { + if (yyextra->currentMemberDef && yyextra->currentMemberDef->isFunction()) + { + yyextra->currentMemberDef->incrementFlowKeyWordCount(); + } + addParmType(yyscanner); + yyextra->parmName=yytext; + startFontClass(yyscanner,"keywordflow"); + yyextra->code->codify(yytext); + endFontClass(yyscanner); + } +<MemberCall2,FuncCall>{ID}(({B}*"<"[^\n\[\](){}<>]*">")?({B}*"::"{B}*{ID})?)* { + if (isCastKeyword(yytext)) + { + REJECT; + } + addParmType(yyscanner); + yyextra->parmName=yytext; + generateClassOrGlobalLink(yyscanner,*yyextra->code,yytext,!yyextra->insideBody); + } +<FuncCall>";" { // probably a cast, not a function call + yyextra->code->codify(yytext); + yyextra->inForEachExpression = FALSE; + BEGIN( Body ); + } +<MemberCall2,FuncCall>, { + yyextra->code->codify(yytext); + yyextra->theVarContext.addVariable(yyscanner,yyextra->parmType,yyextra->parmName); + yyextra->parmType.resize(0);yyextra->parmName.resize(0); + } +<MemberCall2,FuncCall>"{" { + if (yyextra->bracketCount>0) + { + yyextra->code->codify(yytext); + yyextra->skipInlineInitContext=YY_START; + yyextra->curlyCount=0; + BEGIN(InlineInit); + } + else + { + REJECT; + } + } +<InlineInit>"{" { yyextra->curlyCount++; + yyextra->code->codify(yytext); + } +<InlineInit>"}" { + yyextra->code->codify(yytext); + if (--yyextra->curlyCount<=0) + { + BEGIN(yyextra->skipInlineInitContext); + } + } +<InlineInit>\n { + codifyLines(yyscanner,yytext); + } +<InlineInit>. { + yyextra->code->codify(yytext); + } +<MemberCall2,FuncCall>"(" { + yyextra->parmType.resize(0);yyextra->parmName.resize(0); + yyextra->code->codify(yytext); + yyextra->bracketCount++; + yyextra->theCallContext.pushScope(yyextra->name, yyextra->type); + if (YY_START==FuncCall && !yyextra->insideBody) + { + yyextra->theVarContext.pushScope(); + } + } +<MemberCall2,FuncCall>{OPERATOR} { // operator + if (qstrcmp(yytext,"*") && + qstrcmp(yytext,"&") && + qstrcmp(yytext,"^") && + qstrcmp(yytext,"%")) // typically a pointer or reference + { + // not a * or &, or C++/CLI's ^ or % + yyextra->parmType.resize(0);yyextra->parmName.resize(0); + } + yyextra->code->codify(yytext); + } +<MemberCall,MemberCall2,FuncCall>("*"{B}*)?")" { + if (yytext[0]==')') // no a pointer cast + { + //printf("addVariable(%s,%s)\n",yyextra->parmType.data(),yyextra->parmName.data()); + if (yyextra->parmType.isEmpty()) + { + yyextra->parmType=yyextra->parmName; + yyextra->parmName.resize(0); + } + yyextra->theVarContext.addVariable(yyscanner,yyextra->parmType,yyextra->parmName); + } + else + { + yyextra->parmType = yyextra->parmName; + yyextra->parmName.resize(0); + yyextra->theVarContext.addVariable(yyscanner,yyextra->parmType,yyextra->parmName); + } + yyextra->theCallContext.popScope(yyextra->name, yyextra->type); + yyextra->inForEachExpression = FALSE; + //yyextra->theCallContext.setClass(0); // commented out, otherwise a()->b() does not work for b(). + yyextra->code->codify(yytext); + if (--yyextra->bracketCount<=0) + { + if (yyextra->name.isEmpty()) + { + BEGIN( Body ); + } + else + { + BEGIN( CallEnd ); + } + } + } +<CallEnd>[ \t\n]* { codifyLines(yyscanner,yytext); } + /* +<MemberCall2,FuncCall>")"[ \t\n]*[;:] { + */ +<CallEnd>[;:] { + codifyLines(yyscanner,yytext); + yyextra->bracketCount=0; + if (*yytext==';') yyextra->searchingForBody=FALSE; + if (!yyextra->type.isEmpty()) + { + DBG_CTX((stderr,"add variable yyextra->type=%s yyextra->name=%s)\n",yyextra->type.data(),yyextra->name.data())); + yyextra->theVarContext.addVariable(yyscanner,yyextra->type,yyextra->name); + } + yyextra->parmType.resize(0);yyextra->parmName.resize(0); + yyextra->theCallContext.setScope(0); + if (*yytext==';' || yyextra->insideBody) + { + if (!yyextra->insideBody) + { + yyextra->theVarContext.popScope(); + } + yyextra->name.resize(0);yyextra->type.resize(0); + BEGIN( Body ); + } + else + { + yyextra->bracketCount=0; + BEGIN( SkipInits ); + } + } +<CallEnd>("const"|"volatile"|"sealed"|"override")({BN}+("const"|"volatile"|"sealed"|"override"))*/{BN}*(";"|"="|"throw"{BN}*"(") { + startFontClass(yyscanner,"keyword"); + codifyLines(yyscanner,yytext); + endFontClass(yyscanner); + } +<CallEnd,OldStyleArgs>("const"|"volatile"|"sealed"|"override")*({BN}+("const"|"volatile"|"sealed"|"override"))*{BN}*"{" { + if (yyextra->insideBody) + { + yyextra->theVarContext.pushScope(); + } + yyextra->theVarContext.addVariable(yyscanner,yyextra->parmType,yyextra->parmName); + //yyextra->theCallContext.popScope(yyextra->name, yyextra->type); + yyextra->parmType.resize(0);yyextra->parmName.resize(0); + int index = yyextra->name.findRev("::"); + DBG_CTX((stderr,"yyextra->name=%s\n",yyextra->name.data())); + if (index!=-1) + { + QCString scope = yyextra->name.left(index); + if (!yyextra->classScope.isEmpty()) scope.prepend(yyextra->classScope+"::"); + const ClassDef *cd=getResolvedClass(Doxygen::globalScope,yyextra->sourceFileDef,scope); + if (cd) + { + setClassScope(yyscanner,cd->name()); + yyextra->scopeStack.push(SCOPEBLOCK); + DBG_CTX((stderr,"** scope stack push SCOPEBLOCK\n")); + } + else + { + //setClassScope(yyscanner,yyextra->realScope); + yyextra->scopeStack.push(INNERBLOCK); + DBG_CTX((stderr,"** scope stack push INNERBLOCK\n")); + } + } + else + { + DBG_CTX((stderr,"** scope stack push INNERBLOCK\n")); + yyextra->scopeStack.push(INNERBLOCK); + } + yytext[yyleng-1]='\0'; + QCString cv(yytext); + if (!cv.stripWhiteSpace().isEmpty()) + { + startFontClass(yyscanner,"keyword"); + codifyLines(yyscanner,yytext); + endFontClass(yyscanner); + } + else // just whitespace + { + codifyLines(yyscanner,yytext); + } + yyextra->code->codify("{"); + if (yyextra->searchingForBody) + { + yyextra->searchingForBody=FALSE; + yyextra->insideBody=TRUE; + } + if (yyextra->insideBody) yyextra->bodyCurlyCount++; + yyextra->type.resize(0); yyextra->name.resize(0); + BEGIN( Body ); + } +<CallEnd>"try" { // function-try-block + startFontClass(yyscanner,"keyword"); + yyextra->code->codify(yytext); + endFontClass(yyscanner); + yyextra->inFunctionTryBlock=TRUE; + } +<CallEnd>{ID} { + if (yyextra->insideBody || !yyextra->parmType.isEmpty()) + { + REJECT; + } + // could be K&R style definition + addParmType(yyscanner); + yyextra->parmName=yytext; + generateClassOrGlobalLink(yyscanner,*yyextra->code,yytext,!yyextra->insideBody); + BEGIN(OldStyleArgs); + } +<OldStyleArgs>{ID} { + addParmType(yyscanner); + yyextra->parmName=yytext; + generateClassOrGlobalLink(yyscanner,*yyextra->code,yytext,!yyextra->insideBody); + } +<OldStyleArgs>[,;] { + yyextra->code->codify(yytext); + yyextra->theVarContext.addVariable(yyscanner,yyextra->parmType,yyextra->parmName); + if (*yytext==';') yyextra->parmType.resize(0); + yyextra->parmName.resize(0); + } +<CallEnd,OldStyleArgs>"#" { + startFontClass(yyscanner,"preprocessor"); + yyextra->lastSkipCppContext = Body; + yyextra->code->codify(yytext); + BEGIN( SkipCPP ); + } +<CallEnd>. { + unput(*yytext); + if (!yyextra->insideBody) + { + yyextra->theVarContext.popScope(); + } + yyextra->name.resize(0);yyextra->args.resize(0); + yyextra->parmType.resize(0);yyextra->parmName.resize(0); + BEGIN( Body ); + } +<SkipInits>";" { + yyextra->code->codify(yytext); + yyextra->type.resize(0); yyextra->name.resize(0); + BEGIN( Body ); + } +<SkipInits>"{" { + yyextra->code->codify(yytext); + if (yyextra->searchingForBody) + { + yyextra->searchingForBody=FALSE; + yyextra->insideBody=TRUE; + } + if (yyextra->insideBody) yyextra->bodyCurlyCount++; + if (yyextra->name.find("::")!=-1) + { + DBG_CTX((stderr,"** scope stack push SCOPEBLOCK\n")); + yyextra->scopeStack.push(SCOPEBLOCK); + setClassScope(yyscanner,yyextra->realScope); + } + else + { + DBG_CTX((stderr,"** scope stack push INNERBLOCK\n")); + yyextra->scopeStack.push(INNERBLOCK); + } + yyextra->type.resize(0); yyextra->name.resize(0); + BEGIN( Body ); + } +<SkipInits>{ID} { + generateClassOrGlobalLink(yyscanner,*yyextra->code,yytext); + } +<FuncCall>{ID}/"(" { + generateFunctionLink(yyscanner,*yyextra->code,yytext); + } +<FuncCall>{ID}/("."|"->") { + yyextra->name=yytext; + generateClassOrGlobalLink(yyscanner,*yyextra->code,yytext); + BEGIN( MemberCall2 ); + } +<FuncCall,MemberCall2>("("{B}*("*"{B}*)+{ID}*{B}*")"{B}*)/("."|"->") { + yyextra->code->codify(yytext); + int s=0;while (!isId(yytext[s])) s++; + int e=(int)yyleng-1;while (!isId(yytext[e])) e--; + yyextra->name=((QCString)yytext).mid(s,e-s+1); + BEGIN( MemberCall2 ); + } +<MemberCall2>{ID}/([ \t\n]*"(") { + if (!yyextra->args.isEmpty()) + generateMemberLink(yyscanner,*yyextra->code,yyextra->args,yytext); + else + generateClassOrGlobalLink(yyscanner,*yyextra->code,yytext); + yyextra->args.resize(0); + BEGIN( FuncCall ); + } +<MemberCall2>{ID}/([ \t\n]*("."|"->")) { + //yyextra->code->codify(yytext); + yyextra->name=yytext; + generateClassOrGlobalLink(yyscanner,*yyextra->code,yytext); + BEGIN( MemberCall2 ); + } +<MemberCall2>"->"|"." { + if (yytext[0]=='-') // -> could be overloaded + { + updateCallContextForSmartPointer(yyscanner); + } + yyextra->code->codify(yytext); + yyextra->memCallContext = YY_START; + BEGIN( MemberCall ); + } +<SkipComment>"/*"("!"?)"*/" { + yyextra->code->codify(yytext); + endFontClass(yyscanner); + BEGIN( yyextra->lastCContext ) ; + } +<SkipComment>"//"|"/*" { + yyextra->code->codify(yytext); + } +<SkipComment>[^*/\n]+ { + yyextra->code->codify(yytext); + } +<SkipComment>[ \t]*"*/" { + yyextra->code->codify(yytext); + endFontClass(yyscanner); + if (yyextra->lastCContext==SkipCPP) + { + startFontClass(yyscanner,"preprocessor"); + } + BEGIN( yyextra->lastCContext ) ; + } +<SkipCxxComment>[^\r\n]*"\\"[\r]?\n { // line continuation + codifyLines(yyscanner,yytext); + } +<SkipCxxComment>[^\r\n]+ { + yyextra->code->codify(yytext); + } +<SkipCxxComment>\r +<SkipCxxComment>\n { + unput('\n'); + endFontClass(yyscanner); + BEGIN( yyextra->lastCContext ) ; + } +<SkipCxxComment>. { + yyextra->code->codify(yytext); + } +<RemoveSpecialCComment>"*/"{B}*\n({B}*\n)*({B}*(("//@"[{}])|("/*@"[{}]"*/")){B}*\n)?{B}*"/*"[*!]/[^/*] { + yyextra->yyLineNr+=QCString(yytext).contains('\n'); + } +<RemoveSpecialCComment>"*/"{B}*\n({B}*\n)*({B}*(("//@"[{}])|("/*@"[{}]"*/")){B}*\n)? { + yyextra->yyLineNr+=QCString(yytext).contains('\n'); + nextCodeLine(yyscanner); + if (yyextra->lastSpecialCContext==SkipCxxComment) + { // force end of C++ comment here + endFontClass(yyscanner); + BEGIN( yyextra->lastCContext ) ; + } + else + { + BEGIN(yyextra->lastSpecialCContext); + } + } +<RemoveSpecialCComment>"*/" { + BEGIN(yyextra->lastSpecialCContext); + } +<RemoveSpecialCComment>[^*\n]+ +<RemoveSpecialCComment>"//"|"/*" +<RemoveSpecialCComment>\n { yyextra->yyLineNr++; } +<RemoveSpecialCComment>. +<MemberCall>[^a-z_A-Z0-9(\n] { + yyextra->code->codify(yytext); + yyextra->type.resize(0); + yyextra->name.resize(0); + BEGIN(yyextra->memCallContext); + } +<*>\n({B}*"//"[!/][^\n]*\n)+ { // remove special one-line comment + if (YY_START==SkipCPP) REJECT; + if (Config_getBool(STRIP_CODE_COMMENTS)) + { + yyextra->yyLineNr+=((QCString)yytext).contains('\n'); + nextCodeLine(yyscanner); + } + else + { + startFontClass(yyscanner,"comment"); + codifyLines(yyscanner,yytext); + endFontClass(yyscanner); + } + if (YY_START==SkipCxxComment) + { + endFontClass(yyscanner); + BEGIN( yyextra->lastCContext ) ; + } + } +<SkipCPP>\n/.*\n { + endFontClass(yyscanner); + codifyLines(yyscanner,yytext); + BEGIN( yyextra->lastSkipCppContext ) ; + } +<*>\n{B}*"//@"[{}].*\n { // remove one-line group marker + if (Config_getBool(STRIP_CODE_COMMENTS)) + { + yyextra->yyLineNr+=2; + nextCodeLine(yyscanner); + } + else + { + startFontClass(yyscanner,"comment"); + codifyLines(yyscanner,yytext); + endFontClass(yyscanner); + } + if (YY_START==SkipCxxComment) + { + endFontClass(yyscanner); + BEGIN( yyextra->lastCContext ) ; + } + } +<*>\n{B}*"/*@"[{}] { // remove one-line group marker + if (Config_getBool(STRIP_CODE_COMMENTS)) + { + if (YY_START != RemoveSpecialCComment) yyextra->lastSpecialCContext = YY_START; + yyextra->yyLineNr++; + BEGIN(RemoveSpecialCComment); + } + else + { + // check is to prevent getting stuck in skipping C++ comments + if (YY_START != SkipComment && YY_START != SkipCxxComment) + { + yyextra->lastCContext = YY_START ; + } + startFontClass(yyscanner,"comment"); + codifyLines(yyscanner,yytext); + BEGIN(SkipComment); + } + } +<*>^{B}*"//@"[{}].*\n { // remove one-line group marker + if (Config_getBool(STRIP_CODE_COMMENTS)) + { + yyextra->yyLineNr++; + nextCodeLine(yyscanner); + } + else + { + startFontClass(yyscanner,"comment"); + codifyLines(yyscanner,yytext); + endFontClass(yyscanner); + } + } +<*>^{B}*"/*@"[{}] { // remove multi-line group marker + if (Config_getBool(STRIP_CODE_COMMENTS)) + { + if (YY_START != RemoveSpecialCComment) yyextra->lastSpecialCContext = YY_START; + BEGIN(RemoveSpecialCComment); + } + else + { + // check is to prevent getting stuck in skipping C++ comments + if (YY_START != SkipComment && YY_START != SkipCxxComment) + { + yyextra->lastCContext = YY_START ; + } + startFontClass(yyscanner,"comment"); + yyextra->code->codify(yytext); + BEGIN(SkipComment); + } + } +<*>^{B}*"//"[!/][^\n]*\n { // remove special one-line comment + if (Config_getBool(STRIP_CODE_COMMENTS)) + { + yyextra->yyLineNr++; + //nextCodeLine(yyscanner); + } + else + { + startFontClass(yyscanner,"comment"); + codifyLines(yyscanner,yytext); + endFontClass(yyscanner); + } + } +<*>"//"[!/][^\n]*\n { // strip special one-line comment + if (YY_START==SkipComment || YY_START==SkipString) REJECT; + if (Config_getBool(STRIP_CODE_COMMENTS)) + { + char c[2]; c[0]='\n'; c[1]=0; + codifyLines(yyscanner,c); + } + else + { + startFontClass(yyscanner,"comment"); + codifyLines(yyscanner,yytext); + endFontClass(yyscanner); + } + } +<*>"/*[tag:"[^\]\n]*"]*/"{B}* { // special pattern /*[tag:filename]*/ to force linking to a tag file + yyextra->forceTagReference=yytext; + int s=yyextra->forceTagReference.find(':'); + int e=yyextra->forceTagReference.findRev(']'); + yyextra->forceTagReference = yyextra->forceTagReference.mid(s+1,e-s-1); + } +<*>\n{B}*"/*"[!*]/[^/*] { + if (Config_getBool(STRIP_CODE_COMMENTS)) + { + if (YY_START != RemoveSpecialCComment) yyextra->lastSpecialCContext = YY_START; + yyextra->yyLineNr++; + BEGIN(RemoveSpecialCComment); + } + else + { + // check is to prevent getting stuck in skipping C++ comments + if (YY_START != SkipComment && YY_START != SkipCxxComment) + { + yyextra->lastCContext = YY_START ; + } + startFontClass(yyscanner,"comment"); + codifyLines(yyscanner,yytext); + BEGIN(SkipComment); + } + } +<*>^{B}*"/**"[*]+/[^/] { // special C "banner" comment block at a new line + if (Config_getBool(JAVADOC_BANNER) && Config_getBool(STRIP_CODE_COMMENTS)) + { + if (YY_START != RemoveSpecialCComment) yyextra->lastSpecialCContext = YY_START; + BEGIN(RemoveSpecialCComment); + } + else + { + // check is to prevent getting stuck in skipping C++ comments + if (YY_START != SkipComment && YY_START != SkipCxxComment) + { + yyextra->lastCContext = YY_START ; + } + startFontClass(yyscanner,"comment"); + yyextra->code->codify(yytext); + BEGIN(SkipComment); + } + } +<*>^{B}*"/*"[!*]/[^/*] { // special C comment block at a new line + if (Config_getBool(STRIP_CODE_COMMENTS)) + { + if (YY_START != RemoveSpecialCComment) yyextra->lastSpecialCContext = YY_START; + BEGIN(RemoveSpecialCComment); + } + else + { + // check is to prevent getting stuck in skipping C++ comments + if (YY_START != SkipComment && YY_START != SkipCxxComment) + { + yyextra->lastCContext = YY_START ; + } + startFontClass(yyscanner,"comment"); + yyextra->code->codify(yytext); + BEGIN(SkipComment); + } + } +<*>"/*"[!*]/[^/*] { // special C comment block half way a line + if (YY_START==SkipString) REJECT; + if (Config_getBool(STRIP_CODE_COMMENTS)) + { + if (YY_START != RemoveSpecialCComment) yyextra->lastSpecialCContext = YY_START; + BEGIN(RemoveSpecialCComment); + } + else + { + // check is to prevent getting stuck in skipping C++ comments + if (YY_START != SkipComment && YY_START != SkipCxxComment) + { + yyextra->lastCContext = YY_START ; + } + startFontClass(yyscanner,"comment"); + yyextra->code->codify(yytext); + BEGIN(SkipComment); + } + } +<*>"/*"("!"?)"*/" { + if (YY_START==SkipString) REJECT; + if (!Config_getBool(STRIP_CODE_COMMENTS)) + { + startFontClass(yyscanner,"comment"); + yyextra->code->codify(yytext); + endFontClass(yyscanner); + } + } +<SkipComment>[^\*\n]+ { + yyextra->code->codify(yytext); + } +<*>"/*" { + startFontClass(yyscanner,"comment"); + yyextra->code->codify(yytext); + // check is to prevent getting stuck in skipping C++ comments + if (YY_START != SkipComment && YY_START != SkipCxxComment) + { + yyextra->lastCContext = YY_START ; + } + BEGIN( SkipComment ) ; + } +<*>@\" { // C# verbatim string + startFontClass(yyscanner,"stringliteral"); + yyextra->code->codify(yytext); + yyextra->lastVerbStringContext=YY_START; + BEGIN(SkipVerbString); + } +<*>"//" { + startFontClass(yyscanner,"comment"); + yyextra->code->codify(yytext); + yyextra->lastCContext = YY_START ; + BEGIN( SkipCxxComment ) ; + } +<*>"("|"[" { + yyextra->code->codify(yytext); + yyextra->theCallContext.pushScope(yyextra->name, yyextra->type); + } +<*>")"|"]" { + yyextra->code->codify(yytext); + yyextra->theCallContext.popScope(yyextra->name, yyextra->type); + } +<*>\n { + yyextra->yyColNr++; + codifyLines(yyscanner,yytext); + } +<*>. { + yyextra->yyColNr++; + yyextra->code->codify(yytext); + } + /* +<*>([ \t\n]*"\n"){2,} { // combine multiple blank lines + //QCString sepLine=yytext; + //yyextra->code->codify("\n\n"); + //yyextra->yyLineNr+=sepLine.contains('\n'); + //char sepLine[3]="\n\n"; + codifyLines(yyscanner,yytext); + } + */ + +%% + +/*@ ---------------------------------------------------------------------------- + */ + +void VariableContext::addVariable(yyscan_t yyscanner,const QCString &type,const QCString &name) { + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; //printf("VariableContext::addVariable(%s,%s)\n",type.data(),name.data()); QCString ltype = type.simplifyWhiteSpace(); QCString lname = name.simplifyWhiteSpace(); @@ -257,8 +2268,8 @@ void VariableContext::addVariable(const QCString &type,const QCString &name) const ClassDef *varType; int i=0; if ( - (varType=g_codeClassSDict->find(ltype)) || // look for class definitions inside the code block - (varType=getResolvedClass(g_currentDefinition,g_sourceFileDef,ltype)) // look for global class definitions + (varType=yyextra->codeClassSDict->find(ltype)) || // look for class definitions inside the code block + (varType=getResolvedClass(yyextra->currentDefinition,yyextra->sourceFileDef,ltype)) // look for global class definitions ) { DBG_CTX((stderr,"** addVariable type='%s' name='%s'\n",ltype.data(),lname.data())); @@ -272,9 +2283,9 @@ void VariableContext::addVariable(const QCString &type,const QCString &name) QCString templateArgs(ltype.right(ltype.length() - i)); if ( !typeName.isEmpty() && ( // look for class definitions inside the code block - (varType=g_codeClassSDict->find(typeName)) || + (varType=yyextra->codeClassSDict->find(typeName)) || // otherwise look for global class definitions - (varType=getResolvedClass(g_currentDefinition,g_sourceFileDef,typeName,0,0,TRUE,TRUE)) + (varType=getResolvedClass(yyextra->currentDefinition,yyextra->sourceFileDef,typeName,0,0,TRUE,TRUE)) ) && // and it must be a template !varType->templateArguments().empty()) { @@ -288,7 +2299,7 @@ void VariableContext::addVariable(const QCString &type,const QCString &name) else { // Doesn't seem to be a template. Try just the base name. - addVariable(typeName,name); + addVariable(yyscanner,typeName,name); } } else @@ -330,137 +2341,73 @@ ClassDef *VariableContext::findVariable(const QCString &name) return result; } -static VariableContext g_theVarContext; const ClassDef *VariableContext::dummyContext = (ClassDef*)0x8; //------------------------------------------------------------------- -class CallContext -{ - public: - struct Ctx - { - Ctx(QCString _name, QCString _type) : name(_name), type(_type), d(0) {} - QCString name; - QCString type; - const Definition *d; - }; - - CallContext() - { - m_defList.append(new Ctx("","")); - m_defList.setAutoDelete(TRUE); - } - virtual ~CallContext() {} - void setScope(const Definition *d) - { - Ctx *ctx = m_defList.getLast(); - if (ctx) - { - DBG_CTX((stderr,"** Set call context %s (%p)\n",d==0 ? "<null>" : d->name().data(),d)); - ctx->d=d; - } - } - void pushScope(QCString _name, QCString _type) - { - m_defList.append(new Ctx(_name,_type)); - DBG_CTX((stderr,"** Push call context %d\n",m_defList.count())); - } - void popScope(QCString &_name, QCString &_type) - { - if (m_defList.count()>1) - { - DBG_CTX((stderr,"** Pop call context %d\n",m_defList.count())); - Ctx *ctx = m_defList.getLast(); - if (ctx) - { - _name = ctx->name; - _type = ctx->type; - } - m_defList.removeLast(); - } - else - { - DBG_CTX((stderr,"** ILLEGAL: Pop call context\n")); - } - } - void clear() - { - DBG_CTX((stderr,"** Clear call context\n")); - m_defList.clear(); - m_defList.append(new Ctx("","")); - } - const Definition *getScope() const - { - Ctx *ctx = m_defList.getLast(); - if (ctx) return ctx->d; else return 0; - } - - private: - QList<Ctx> m_defList; -}; - -static CallContext g_theCallContext; - -//------------------------------------------------------------------- - /*! add class/namespace name s to the scope */ -static void pushScope(const char *s) +static void pushScope(yyscan_t yyscanner,const char *s) { - g_classScopeLengthStack.push(new int(g_classScope.length())); - if (g_classScope.isEmpty() || leftScopeMatch(s,g_classScope)) + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; + yyextra->classScopeLengthStack.push(new int(yyextra->classScope.length())); + if (yyextra->classScope.isEmpty() || leftScopeMatch(s,yyextra->classScope)) { - g_classScope = s; + yyextra->classScope = s; } else { - g_classScope += "::"; - g_classScope += s; + yyextra->classScope += "::"; + yyextra->classScope += s; } - //printf("pushScope(%s) result: '%s'\n",s,g_classScope.data()); + //printf("pushScope(%s) result: '%s'\n",s,yyextra->classScope.data()); } + /*! remove the top class/namespace name from the scope */ -static void popScope() +static void popScope(yyscan_t yyscanner) { - if (!g_classScopeLengthStack.isEmpty()) + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; + if (!yyextra->classScopeLengthStack.isEmpty()) { - int *pLength = g_classScopeLengthStack.pop(); - g_classScope.truncate(*pLength); + int *pLength = yyextra->classScopeLengthStack.pop(); + yyextra->classScope.truncate(*pLength); delete pLength; } else { //err("Too many end of scopes found!\n"); } - //printf("popScope() result: '%s'\n",g_classScope.data()); + //printf("popScope() result: '%s'\n",yyextra->classScope.data()); } -static void setCurrentDoc(const QCString &anchor) +static void setCurrentDoc(yyscan_t yyscanner,const QCString &anchor) { + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; if (Doxygen::searchIndex) { - if (g_searchCtx) + if (yyextra->searchCtx) { - g_code->setCurrentDoc(g_searchCtx,g_searchCtx->anchor(),FALSE); + yyextra->code->setCurrentDoc(yyextra->searchCtx,yyextra->searchCtx->anchor(),FALSE); } else { - g_code->setCurrentDoc(g_sourceFileDef,anchor,TRUE); + yyextra->code->setCurrentDoc(yyextra->sourceFileDef,anchor,TRUE); } } } -static void addToSearchIndex(const char *text) +static void addToSearchIndex(yyscan_t yyscanner,const char *text) { + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; if (Doxygen::searchIndex) { - g_code->addWord(text,FALSE); + yyextra->code->addWord(text,FALSE); } } -static void setClassScope(const QCString &name) +static void setClassScope(yyscan_t yyscanner,const QCString &name) { + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; //printf("setClassScope(%s)\n",name.data()); QCString n=name; n=n.simplifyWhiteSpace(); @@ -472,132 +2419,134 @@ static void setClassScope(const QCString &name) // remove template from scope n=n.left(ts)+n.right(n.length()-te-1); } - while (!g_classScopeLengthStack.isEmpty()) + while (!yyextra->classScopeLengthStack.isEmpty()) { - popScope(); + popScope(yyscanner); } - g_classScope.resize(0); + yyextra->classScope.resize(0); int i; while ((i=n.find("::"))!=-1) { - pushScope(n.left(i)); + pushScope(yyscanner,n.left(i)); n = n.mid(i+2); } - pushScope(n); - //printf("--->New class scope '%s'\n",g_classScope.data()); + pushScope(yyscanner,n); + //printf("--->New class scope '%s'\n",yyextra->classScope.data()); } -/*! start a new line of code, inserting a line number if g_sourceFileDef +/*! start a new line of code, inserting a line number if yyextra->sourceFileDef * is TRUE. If a definition starts at the current line, then the line * number is linked to the documentation of that definition. */ -static void startCodeLine() +static void startCodeLine(yyscan_t yyscanner) { - //if (g_currentFontClass) { g_code->endFontClass(); } - if (g_sourceFileDef && g_lineNumbers) + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; + //if (yyextra->currentFontClass) { yyextra->code->endFontClass(yyscanner); } + if (yyextra->sourceFileDef && yyextra->lineNumbers) { //QCString lineNumber,lineAnchor; - //lineNumber.sprintf("%05d",g_yyLineNr); - //lineAnchor.sprintf("l%05d",g_yyLineNr); + //lineNumber.sprintf("%05d",yyextra->yyLineNr); + //lineAnchor.sprintf("l%05d",yyextra->yyLineNr); - Definition *d = g_sourceFileDef->getSourceDefinition(g_yyLineNr); - //printf("%s:startCodeLine(%d)=%p\n",g_sourceFileDef->name().data(),g_yyLineNr,d); - if (!g_includeCodeFragment && d) - { - g_currentDefinition = d; - g_currentMemberDef = g_sourceFileDef->getSourceMember(g_yyLineNr); - g_insideBody = FALSE; - g_searchingForBody = TRUE; - g_realScope = d->name(); - //g_classScope = ""; - g_type.resize(0); - g_name.resize(0); - g_args.resize(0); - g_parmType.resize(0); - g_parmName.resize(0); - //printf("Real scope: '%s'\n",g_realScope.data()); - g_bodyCurlyCount = 0; + Definition *d = yyextra->sourceFileDef->getSourceDefinition(yyextra->yyLineNr); + //printf("%s:startCodeLine(%d)=%p\n",yyextra->sourceFileDef->name().data(),yyextra->yyLineNr,d); + if (!yyextra->includeCodeFragment && d) + { + yyextra->currentDefinition = d; + yyextra->currentMemberDef = yyextra->sourceFileDef->getSourceMember(yyextra->yyLineNr); + yyextra->insideBody = FALSE; + yyextra->searchingForBody = TRUE; + yyextra->realScope = d->name(); + //yyextra->classScope = ""; + yyextra->type.resize(0); + yyextra->name.resize(0); + yyextra->args.resize(0); + yyextra->parmType.resize(0); + yyextra->parmName.resize(0); + //printf("Real scope: '%s'\n",yyextra->realScope.data()); + yyextra->bodyCurlyCount = 0; QCString lineAnchor; - lineAnchor.sprintf("l%05d",g_yyLineNr); - if (g_currentMemberDef) + lineAnchor.sprintf("l%05d",yyextra->yyLineNr); + if (yyextra->currentMemberDef) { - g_code->writeLineNumber(g_currentMemberDef->getReference(), - g_currentMemberDef->getOutputFileBase(), - g_currentMemberDef->anchor(),g_yyLineNr); - setCurrentDoc(lineAnchor); + yyextra->code->writeLineNumber(yyextra->currentMemberDef->getReference(), + yyextra->currentMemberDef->getOutputFileBase(), + yyextra->currentMemberDef->anchor(),yyextra->yyLineNr); + setCurrentDoc(yyscanner,lineAnchor); } else if (d->isLinkableInProject()) { - g_code->writeLineNumber(d->getReference(), + yyextra->code->writeLineNumber(d->getReference(), d->getOutputFileBase(), - 0,g_yyLineNr); - setCurrentDoc(lineAnchor); + 0,yyextra->yyLineNr); + setCurrentDoc(yyscanner,lineAnchor); } } else { - g_code->writeLineNumber(0,0,0,g_yyLineNr); + yyextra->code->writeLineNumber(0,0,0,yyextra->yyLineNr); } } - DBG_CTX((stderr,"startCodeLine(%d)\n",g_yyLineNr)); - g_code->startCodeLine(g_sourceFileDef && g_lineNumbers); - if (g_currentFontClass) + DBG_CTX((stderr,"startCodeLine(%d)\n",yyextra->yyLineNr)); + yyextra->code->startCodeLine(yyextra->sourceFileDef && yyextra->lineNumbers); + if (yyextra->currentFontClass) { - g_code->startFontClass(g_currentFontClass); + yyextra->code->startFontClass(yyextra->currentFontClass); } } -static void endFontClass(); -static void startFontClass(const char *s); -static void endCodeLine() +static void endCodeLine(yyscan_t yyscanner) { - DBG_CTX((stderr,"endCodeLine(%d)\n",g_yyLineNr)); - endFontClass(); - g_code->endCodeLine(); + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; + DBG_CTX((stderr,"endCodeLine(%d)\n",yyextra->yyLineNr)); + endFontClass(yyscanner); + yyextra->code->endCodeLine(); } -static void nextCodeLine() +static void nextCodeLine(yyscan_t yyscanner) { - const char * fc = g_currentFontClass; - endCodeLine(); - if (g_yyLineNr<g_inputLines) + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; + const char * fc = yyextra->currentFontClass; + endCodeLine(yyscanner); + if (yyextra->yyLineNr<yyextra->inputLines) { - g_currentFontClass = fc; - startCodeLine(); + yyextra->currentFontClass = fc; + startCodeLine(yyscanner); } } /*! write a code fragment 'text' that may span multiple lines, inserting * line numbers for each line. */ -static void codifyLines(const char *text) +static void codifyLines(yyscan_t yyscanner,const char *text) { - //printf("codifyLines(%d,\"%s\")\n",g_yyLineNr,text); + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; + //printf("codifyLines(%d,\"%s\")\n",yyextra->yyLineNr,text); const char *p=text,*sp=p; char c; bool done=FALSE; while (!done) { sp=p; - while ((c=*p++) && c!='\n') { g_yyColNr++; } + while ((c=*p++) && c!='\n') { yyextra->yyColNr++; } if (c=='\n') { - g_yyLineNr++; - g_yyColNr=1; + yyextra->yyLineNr++; + yyextra->yyColNr=1; //*(p-1)='\0'; int l = (int)(p-sp-1); char *tmp = (char*)malloc(l+1); memcpy(tmp,sp,l); tmp[l]='\0'; - g_code->codify(tmp); + yyextra->code->codify(tmp); free(tmp); - nextCodeLine(); + nextCodeLine(yyscanner); } else { - g_code->codify(sp); + yyextra->code->codify(sp); done=TRUE; } } @@ -607,10 +2556,11 @@ static void codifyLines(const char *text) * line numbers for each line. If \a text contains newlines, the link will be * split into multiple links with the same destination, one for each line. */ -static void writeMultiLineCodeLink(CodeOutputInterface &ol, +static void writeMultiLineCodeLink(yyscan_t yyscanner,CodeOutputInterface &ol, const Definition *d, const char *text) { + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; static bool sourceTooltips = Config_getBool(SOURCE_TOOLTIPS); TooltipManager::instance()->addTooltip(d); QCString ref = d->getReference(); @@ -630,11 +2580,11 @@ static void writeMultiLineCodeLink(CodeOutputInterface &ol, while ((c=*p++) && c!='\n') { } if (c=='\n') { - g_yyLineNr++; + yyextra->yyLineNr++; *(p-1)='\0'; //printf("writeCodeLink(%s,%s,%s,%s)\n",ref,file,anchor,sp); ol.writeCodeLink(ref,file,anchor,sp,tooltip); - nextCodeLine(); + nextCodeLine(yyscanner); } else { @@ -645,56 +2595,61 @@ static void writeMultiLineCodeLink(CodeOutputInterface &ol, } } -static void addType() +static void addType(yyscan_t yyscanner) { - if (g_name=="const") { g_name.resize(0); return; } - if (!g_type.isEmpty()) g_type += ' ' ; - g_type += g_name ; - g_name.resize(0) ; - if (!g_type.isEmpty()) g_type += ' ' ; - g_type += g_args ; - g_args.resize(0) ; + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; + if (yyextra->name=="const") { yyextra->name.resize(0); return; } + if (!yyextra->type.isEmpty()) yyextra->type += ' ' ; + yyextra->type += yyextra->name ; + yyextra->name.resize(0) ; + if (!yyextra->type.isEmpty()) yyextra->type += ' ' ; + yyextra->type += yyextra->args ; + yyextra->args.resize(0) ; } -static void addParmType() +static void addParmType(yyscan_t yyscanner) { - if (g_parmName=="const") { g_parmName.resize(0); return; } - if (!g_parmType.isEmpty()) g_parmType += ' ' ; - g_parmType += g_parmName ; - g_parmName.resize(0) ; + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; + if (yyextra->parmName=="const") { yyextra->parmName.resize(0); return; } + if (!yyextra->parmType.isEmpty()) yyextra->parmType += ' ' ; + yyextra->parmType += yyextra->parmName ; + yyextra->parmName.resize(0) ; } -static void addUsingDirective(const char *name) +static void addUsingDirective(yyscan_t yyscanner,const char *name) { - if (g_sourceFileDef && name) + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; + if (yyextra->sourceFileDef && name) { NamespaceDef *nd = Doxygen::namespaceSDict->find(name); if (nd) { - g_sourceFileDef->addUsingDirective(nd); + yyextra->sourceFileDef->addUsingDirective(nd); } } } -static void setParameterList(const MemberDef *md) +static void setParameterList(yyscan_t yyscanner,const MemberDef *md) { - g_classScope = md->getClassDef() ? md->getClassDef()->name().data() : ""; + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; + yyextra->classScope = md->getClassDef() ? md->getClassDef()->name().data() : ""; for (const Argument &a : md->argumentList()) { - g_parmName = a.name; - g_parmType = a.type; - int i = g_parmType.find('*'); - if (i!=-1) g_parmType = g_parmType.left(i); - i = g_parmType.find('&'); - if (i!=-1) g_parmType = g_parmType.left(i); - g_parmType.stripPrefix("const "); - g_parmType=g_parmType.stripWhiteSpace(); - g_theVarContext.addVariable(g_parmType,g_parmName); + yyextra->parmName = a.name; + yyextra->parmType = a.type; + int i = yyextra->parmType.find('*'); + if (i!=-1) yyextra->parmType = yyextra->parmType.left(i); + i = yyextra->parmType.find('&'); + if (i!=-1) yyextra->parmType = yyextra->parmType.left(i); + yyextra->parmType.stripPrefix("const "); + yyextra->parmType=yyextra->parmType.stripWhiteSpace(); + yyextra->theVarContext.addVariable(yyscanner,yyextra->parmType,yyextra->parmName); } } -static const ClassDef *stripClassName(const char *s,Definition *d=g_currentDefinition) +static const ClassDef *stripClassName(yyscan_t yyscanner,const char *s,Definition *d) { + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; int pos=0; QCString type = s; QCString className; @@ -703,13 +2658,13 @@ static const ClassDef *stripClassName(const char *s,Definition *d=g_currentDefin { QCString clName=className+templSpec; const ClassDef *cd=0; - if (!g_classScope.isEmpty()) + if (!yyextra->classScope.isEmpty()) { - cd=getResolvedClass(d,g_sourceFileDef,g_classScope+"::"+clName); + cd=getResolvedClass(d,yyextra->sourceFileDef,yyextra->classScope+"::"+clName); } if (cd==0) { - cd=getResolvedClass(d,g_sourceFileDef,clName); + cd=getResolvedClass(d,yyextra->sourceFileDef,clName); } //printf("stripClass trying '%s' = %p\n",clName.data(),cd); if (cd) @@ -721,10 +2676,11 @@ static const ClassDef *stripClassName(const char *s,Definition *d=g_currentDefin return 0; } -static MemberDef *setCallContextForVar(const QCString &name) +static MemberDef *setCallContextForVar(yyscan_t yyscanner,const QCString &name) { if (name.isEmpty()) return 0; - DBG_CTX((stderr,"setCallContextForVar(%s) g_classScope=%s\n",name.data(),g_classScope.data())); + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; + DBG_CTX((stderr,"setCallContextForVar(%s) yyextra->classScope=%s\n",name.data(),yyextra->classScope.data())); int scopeEnd = name.findRev("::"); if (scopeEnd!=-1) // name with explicit scope @@ -739,7 +2695,7 @@ static MemberDef *setCallContextForVar(const QCString &name) if (md) { //printf("name=%s scope=%s\n",locName.data(),scope.data()); - g_theCallContext.setScope(stripClassName(md->typeString(),md->getOuterScope())); + yyextra->theCallContext.setScope(stripClassName(yyscanner,md->typeString(),md->getOuterScope())); return md; } } @@ -752,7 +2708,7 @@ static MemberDef *setCallContextForVar(const QCString &name) if (md) { //printf("name=%s scope=%s\n",locName.data(),scope.data()); - g_theCallContext.setScope(stripClassName(md->typeString(),md->getOuterScope())); + yyextra->theCallContext.setScope(stripClassName(yyscanner,md->typeString(),md->getOuterScope())); return md; } } @@ -760,21 +2716,21 @@ static MemberDef *setCallContextForVar(const QCString &name) } MemberName *mn; - ClassDef *mcd = g_theVarContext.findVariable(name); + ClassDef *mcd = yyextra->theVarContext.findVariable(name); if (mcd) // local variable { DBG_CTX((stderr,"local variable?\n")); if (mcd!=VariableContext::dummyContext) { DBG_CTX((stderr,"local var '%s' mcd=%s\n",name.data(),mcd->name().data())); - g_theCallContext.setScope(mcd); + yyextra->theCallContext.setScope(mcd); } } else { - DBG_CTX((stderr,"class member? scope=%s\n",g_classScope.data())); + DBG_CTX((stderr,"class member? scope=%s\n",yyextra->classScope.data())); // look for a class member - mcd = getClass(g_classScope); + mcd = getClass(yyextra->classScope); if (mcd) { DBG_CTX((stderr,"Inside class %s\n",mcd->name().data())); @@ -782,10 +2738,10 @@ static MemberDef *setCallContextForVar(const QCString &name) if (md) { DBG_CTX((stderr,"Found member %s\n",md->name().data())); - if (g_scopeStack.top()!=CLASSBLOCK) + if (yyextra->scopeStack.top()!=CLASSBLOCK) { DBG_CTX((stderr,"class member '%s' mcd=%s\n",name.data(),mcd->name().data())); - g_theCallContext.setScope(stripClassName(md->typeString(),md->getOuterScope())); + yyextra->theCallContext.setScope(stripClassName(yyscanner,md->typeString(),md->getOuterScope())); } return md; } @@ -799,9 +2755,9 @@ static MemberDef *setCallContextForVar(const QCString &name) if (mn->count()==1) // global defined only once { MemberDef *md=mn->getFirst(); - if (!md->isStatic() || md->getBodyDef()==g_sourceFileDef) + if (!md->isStatic() || md->getBodyDef()==yyextra->sourceFileDef) { - g_theCallContext.setScope(stripClassName(md->typeString(),md->getOuterScope())); + yyextra->theCallContext.setScope(stripClassName(yyscanner,md->typeString(),md->getOuterScope())); return md; } return 0; @@ -812,19 +2768,19 @@ static MemberDef *setCallContextForVar(const QCString &name) MemberDef *md; for (;(md=it.current());++it) { - //printf("mn=%p md=%p md->getBodyDef()=%p g_sourceFileDef=%p\n", + //printf("mn=%p md=%p md->getBodyDef()=%p yyextra->sourceFileDef=%p\n", // mn,md, - // md->getBodyDef(),g_sourceFileDef); + // md->getBodyDef(),yyextra->sourceFileDef); // in case there are multiple members we could link to, we // only link to members if defined in the same file or // defined as external. - if ((!md->isStatic() || md->getBodyDef()==g_sourceFileDef) && - (g_forceTagReference.isEmpty() || g_forceTagReference==md->getReference()) + if ((!md->isStatic() || md->getBodyDef()==yyextra->sourceFileDef) && + (yyextra->forceTagReference.isEmpty() || yyextra->forceTagReference==md->getReference()) ) { - g_theCallContext.setScope(stripClassName(md->typeString(),md->getOuterScope())); - //printf("returning member %s in source file %s\n",md->name().data(),g_sourceFileDef->name().data()); + yyextra->theCallContext.setScope(stripClassName(yyscanner,md->typeString(),md->getOuterScope())); + //printf("returning member %s in source file %s\n",md->name().data(),yyextra->sourceFileDef->name().data()); return md; } } @@ -834,52 +2790,55 @@ static MemberDef *setCallContextForVar(const QCString &name) return 0; } -static void updateCallContextForSmartPointer() +static void updateCallContextForSmartPointer(yyscan_t yyscanner) { - const Definition *d = g_theCallContext.getScope(); + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; + const Definition *d = yyextra->theCallContext.getScope(); //printf("updateCallContextForSmartPointer() cd=%s\n",cd ? d->name().data() : "<none>"); MemberDef *md; if (d && d->definitionType()==Definition::TypeClass && (md=(dynamic_cast<const ClassDef*>(d))->isSmartPointer())) { - const ClassDef *ncd = stripClassName(md->typeString(),md->getOuterScope()); + const ClassDef *ncd = stripClassName(yyscanner,md->typeString(),md->getOuterScope()); if (ncd) { - g_theCallContext.setScope(ncd); + yyextra->theCallContext.setScope(ncd); //printf("Found smart pointer call %s->%s!\n",cd->name().data(),ncd->name().data()); } } } -static bool getLinkInScope(const QCString &c, // scope +static bool getLinkInScope(yyscan_t yyscanner, + const QCString &c, // scope const QCString &m, // member const char *memberText, // exact text CodeOutputInterface &ol, const char *text, - bool varOnly=FALSE + bool varOnly ) { + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; const MemberDef *md = 0; const ClassDef *cd = 0; const FileDef *fd = 0; const NamespaceDef *nd = 0; const GroupDef *gd = 0; DBG_CTX((stderr,"getLinkInScope: trying '%s'::'%s' varOnly=%d\n",c.data(),m.data(),varOnly)); - if (getDefs(c,m,"()",md,cd,fd,nd,gd,FALSE,g_sourceFileDef,FALSE,g_forceTagReference) && + if (getDefs(c,m,"()",md,cd,fd,nd,gd,FALSE,yyextra->sourceFileDef,FALSE,yyextra->forceTagReference) && (!varOnly || md->isVariable())) { if (md->isLinkable()) { //printf("found it %s!\n",md->qualifiedName().data()); - if (g_exampleBlock) + if (yyextra->exampleBlock) { QCString anchor; - anchor.sprintf("a%d",g_anchorCount); - //printf("addExampleFile(%s,%s,%s)\n",anchor.data(),g_exampleName.data(), - // g_exampleFile.data()); - if (const_cast<MemberDef*>(md)->addExample(anchor,g_exampleName,g_exampleFile)) + anchor.sprintf("a%d",yyextra->anchorCount); + //printf("addExampleFile(%s,%s,%s)\n",anchor.data(),yyextra->exampleName.data(), + // yyextra->exampleFile.data()); + if (const_cast<MemberDef*>(md)->addExample(anchor,yyextra->exampleName,yyextra->exampleFile)) { ol.writeCodeAnchor(anchor); - g_anchorCount++; + yyextra->anchorCount++; } } @@ -888,19 +2847,19 @@ static bool getLinkInScope(const QCString &c, // scope if (md->resolveAlias()->getGroupDef()) d = md->resolveAlias()->getGroupDef(); if (d && d->isLinkable()) { - g_theCallContext.setScope(stripClassName(md->typeString(),md->getOuterScope())); - //printf("g_currentDefinition=%p g_currentMemberDef=%p g_insideBody=%d\n", - // g_currentDefinition,g_currentMemberDef,g_insideBody); + yyextra->theCallContext.setScope(stripClassName(yyscanner,md->typeString(),md->getOuterScope())); + //printf("yyextra->currentDefinition=%p yyextra->currentMemberDef=%p yyextra->insideBody=%d\n", + // yyextra->currentDefinition,yyextra->currentMemberDef,yyextra->insideBody); - if (g_currentDefinition && g_currentMemberDef && - md!=g_currentMemberDef && g_insideBody && g_collectXRefs) + if (yyextra->currentDefinition && yyextra->currentMemberDef && + md!=yyextra->currentMemberDef && yyextra->insideBody && yyextra->collectXRefs) { - addDocCrossReference(g_currentMemberDef,const_cast<MemberDef*>(md)); + addDocCrossReference(yyextra->currentMemberDef,const_cast<MemberDef*>(md)); } //printf("d->getReference()='%s' d->getOutputBase()='%s' name='%s' member name='%s'\n",d->getReference().data(),d->getOutputFileBase().data(),d->name().data(),md->name().data()); - writeMultiLineCodeLink(ol,md, text ? text : memberText); - addToSearchIndex(text ? text : memberText); + writeMultiLineCodeLink(yyscanner,ol,md, text ? text : memberText); + addToSearchIndex(yyscanner,text ? text : memberText); return TRUE; } } @@ -908,54 +2867,60 @@ static bool getLinkInScope(const QCString &c, // scope // to the previous member, see bug762760 { DBG_CTX((stderr,"unlinkable member %s\n",md->name().data())); - g_currentMemberDef = 0; + yyextra->currentMemberDef = 0; } } return FALSE; } -static bool getLink(const char *className, +static bool getLink(yyscan_t yyscanner, + const char *className, const char *memberName, CodeOutputInterface &ol, - const char *text=0, - bool varOnly=FALSE) + const char *text, + bool varOnly) { - //printf("getLink(%s,%s) g_curClassName=%s\n",className,memberName,g_curClassName.data()); + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; + //printf("getLink(%s,%s) yyextra->curClassName=%s\n",className,memberName,yyextra->curClassName.data()); QCString m=removeRedundantWhiteSpace(memberName); QCString c=className; - if (!getLinkInScope(c,m,memberName,ol,text,varOnly)) + if (!getLinkInScope(yyscanner,c,m,memberName,ol,text,varOnly)) { - if (!g_curClassName.isEmpty()) + if (!yyextra->curClassName.isEmpty()) { if (!c.isEmpty()) c.prepend("::"); - c.prepend(g_curClassName); - return getLinkInScope(c,m,memberName,ol,text,varOnly); + c.prepend(yyextra->curClassName); + return getLinkInScope(yyscanner,c,m,memberName,ol,text,varOnly); } return FALSE; } return TRUE; } -static void generateClassOrGlobalLink(CodeOutputInterface &ol,const char *clName, - bool typeOnly=FALSE,bool varOnly=FALSE) +static void generateClassOrGlobalLink(yyscan_t yyscanner, + CodeOutputInterface &ol, + const char *clName, + bool typeOnly, + bool varOnly) { + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; int i=0; if (*clName=='~') // correct for matching negated values i.s.o. destructors. { - g_code->codify("~"); + yyextra->code->codify("~"); clName++; } QCString className=clName; if (className.isEmpty()) return; - if (g_insideProtocolList) // for Obj-C + if (yyextra->insideProtocolList) // for Obj-C { className+="-p"; } - if (g_insidePHP) + if (yyextra->lang==SrcLangExt_PHP) { className = substitute(className,"\\","::"); // for PHP namespaces } - else if (g_insideCS || g_insideJava) + else if (yyextra->lang==SrcLangExt_CSharp || yyextra->lang==SrcLangExt_Java) { className = substitute(className,".","::"); // for PHP namespaces } @@ -964,13 +2929,13 @@ static void generateClassOrGlobalLink(CodeOutputInterface &ol,const char *clName bool isLocal=FALSE; //printf("generateClassOrGlobalLink(className=%s)\n",className.data()); - if (!g_prefixed_with_this_keyword || (lcd=g_theVarContext.findVariable(className))==0) // not a local variable + if (!yyextra->prefixed_with_this_keyword || (lcd=yyextra->theVarContext.findVariable(className))==0) // not a local variable { - Definition *d = g_currentDefinition; - //printf("d=%s g_sourceFileDef=%s\n",d?d->name().data():"<none>",g_sourceFileDef?g_sourceFileDef->name().data():"<none>"); - cd = getResolvedClass(d,g_sourceFileDef,className,&md); + Definition *d = yyextra->currentDefinition; + //printf("d=%s yyextra->sourceFileDef=%s\n",d?d->name().data():"<none>",yyextra->sourceFileDef?yyextra->sourceFileDef->name().data():"<none>"); + cd = getResolvedClass(d,yyextra->sourceFileDef,className,&md); DBG_CTX((stderr,"non-local variable name=%s context=%d cd=%s md=%s!\n", - className.data(),g_theVarContext.count(),cd?cd->name().data():"<none>", + className.data(),yyextra->theVarContext.count(),cd?cd->name().data():"<none>", md?md->name().data():"<none>")); if (cd==0 && md==0 && (i=className.find('<'))!=-1) { @@ -978,15 +2943,15 @@ static void generateClassOrGlobalLink(CodeOutputInterface &ol,const char *clName DBG_CTX((stderr,"bareName=%s\n",bareName.data())); if (bareName!=className) { - cd=getResolvedClass(d,g_sourceFileDef,bareName,&md); // try unspecialized version + cd=getResolvedClass(d,yyextra->sourceFileDef,bareName,&md); // try unspecialized version } } const NamespaceDef *nd = getResolvedNamespace(className); if (nd && nd->isLinkable()) { - g_theCallContext.setScope(nd); - addToSearchIndex(className); - writeMultiLineCodeLink(*g_code,nd,clName); + yyextra->theCallContext.setScope(nd); + addToSearchIndex(yyscanner,className); + writeMultiLineCodeLink(yyscanner,*yyextra->code,nd,clName); return; } //printf("md=%s\n",md?md->name().data():"<none>"); @@ -995,7 +2960,7 @@ static void generateClassOrGlobalLink(CodeOutputInterface &ol,const char *clName nd?nd->name().data():"<null>")); if (cd==0 && md==0) // also see if it is variable or enum or enum value { - if (getLink(g_classScope,clName,ol,clName,varOnly)) + if (getLink(yyscanner,yyextra->classScope,clName,ol,clName,varOnly)) { return; } @@ -1007,12 +2972,12 @@ static void generateClassOrGlobalLink(CodeOutputInterface &ol,const char *clName if (lcd!=VariableContext::dummyContext) { //printf("non-dummy context lcd=%s!\n",lcd->name().data()); - g_theCallContext.setScope(lcd); + yyextra->theCallContext.setScope(lcd); // to following is needed for links to a global variable, but is // no good for a link to a local variable that is also a global symbol. - //if (getLink(g_classScope,clName,ol,clName)) + //if (getLink(yyscanner,yyextra->classScope,clName,ol,clName)) //{ //return; //} @@ -1020,35 +2985,35 @@ static void generateClassOrGlobalLink(CodeOutputInterface &ol,const char *clName isLocal=TRUE; DBG_CTX((stderr,"is a local variable cd=%p!\n",cd)); } - g_prefixed_with_this_keyword = FALSE; // discard the "this" prefix for the next calls + yyextra->prefixed_with_this_keyword = FALSE; // discard the "this" prefix for the next calls if (cd && cd->isLinkable()) // is it a linkable class { DBG_CTX((stderr,"is linkable class %s\n",clName)); - if (g_exampleBlock) + if (yyextra->exampleBlock) { QCString anchor; - anchor.sprintf("_a%d",g_anchorCount); - //printf("addExampleClass(%s,%s,%s)\n",anchor.data(),g_exampleName.data(), - // g_exampleFile.data()); - if (const_cast<ClassDef*>(cd)->addExample(anchor,g_exampleName,g_exampleFile)) + anchor.sprintf("_a%d",yyextra->anchorCount); + //printf("addExampleClass(%s,%s,%s)\n",anchor.data(),yyextra->exampleName.data(), + // yyextra->exampleFile.data()); + if (const_cast<ClassDef*>(cd)->addExample(anchor,yyextra->exampleName,yyextra->exampleFile)) { ol.writeCodeAnchor(anchor); - g_anchorCount++; + yyextra->anchorCount++; } } - writeMultiLineCodeLink(ol,cd,clName); - addToSearchIndex(className); - g_theCallContext.setScope(cd); + writeMultiLineCodeLink(yyscanner,ol,cd,clName); + addToSearchIndex(yyscanner,className); + yyextra->theCallContext.setScope(cd); if (md) { const Definition *d = md->getOuterScope()==Doxygen::globalScope ? md->getFileDef() : md->getOuterScope(); if (md->getGroupDef()) d = md->getGroupDef(); if (d && d->isLinkable() && md->isLinkable() && - g_currentMemberDef && g_collectXRefs) + yyextra->currentMemberDef && yyextra->collectXRefs) { - addDocCrossReference(g_currentMemberDef,const_cast<MemberDef*>(md)); + addDocCrossReference(yyextra->currentMemberDef,const_cast<MemberDef*>(md)); } } } @@ -1059,31 +3024,31 @@ static void generateClassOrGlobalLink(CodeOutputInterface &ol,const char *clName { if (md==0) // not found as a typedef { - md = setCallContextForVar(clName); - //printf("setCallContextForVar(%s) md=%p g_currentDefinition=%p\n",clName,md,g_currentDefinition); - if (md && g_currentDefinition) + md = setCallContextForVar(yyscanner,clName); + //printf("setCallContextForVar(%s) md=%p yyextra->currentDefinition=%p\n",clName,md,yyextra->currentDefinition); + if (md && yyextra->currentDefinition) { DBG_CTX((stderr,"%s accessible from %s? %d md->getOuterScope=%s\n", - md->name().data(),g_currentDefinition->name().data(), - isAccessibleFrom(g_currentDefinition,g_sourceFileDef,md), + md->name().data(),yyextra->currentDefinition->name().data(), + isAccessibleFrom(yyextra->currentDefinition,yyextra->sourceFileDef,md), md->getOuterScope()->name().data())); } - if (md && g_currentDefinition && - isAccessibleFrom(g_currentDefinition,g_sourceFileDef,md)==-1) + if (md && yyextra->currentDefinition && + isAccessibleFrom(yyextra->currentDefinition,yyextra->sourceFileDef,md)==-1) { md=0; // variable not accessible } } if (md && (!varOnly || md->isVariable())) { - DBG_CTX((stderr,"is a global md=%p g_currentDefinition=%s linkable=%d\n",md,g_currentDefinition?g_currentDefinition->name().data():"<none>",md->isLinkable())); + DBG_CTX((stderr,"is a global md=%p yyextra->currentDefinition=%s linkable=%d\n",md,yyextra->currentDefinition?yyextra->currentDefinition->name().data():"<none>",md->isLinkable())); if (md->isLinkable()) { QCString text; - if (!g_forceTagReference.isEmpty()) // explicit reference to symbol in tag file + if (!yyextra->forceTagReference.isEmpty()) // explicit reference to symbol in tag file { - text=g_forceTagReference; + text=yyextra->forceTagReference; if (text.right(4)==".tag") // strip .tag if present { text=text.left(text.length()-4); @@ -1097,11 +3062,11 @@ static void generateClassOrGlobalLink(CodeOutputInterface &ol,const char *clName { text=clName; } - writeMultiLineCodeLink(ol,md,text); - addToSearchIndex(clName); - if (g_currentMemberDef && g_collectXRefs) + writeMultiLineCodeLink(yyscanner,ol,md,text); + addToSearchIndex(yyscanner,clName); + if (yyextra->currentMemberDef && yyextra->collectXRefs) { - addDocCrossReference(g_currentMemberDef,const_cast<MemberDef*>(md)); + addDocCrossReference(yyextra->currentMemberDef,const_cast<MemberDef*>(md)); } return; } @@ -1110,13 +3075,17 @@ static void generateClassOrGlobalLink(CodeOutputInterface &ol,const char *clName // nothing found, just write out the word DBG_CTX((stderr,"not found!\n")); - codifyLines(clName); - addToSearchIndex(clName); + codifyLines(yyscanner,clName); + addToSearchIndex(yyscanner,clName); } } -static bool generateClassMemberLink(CodeOutputInterface &ol,MemberDef *xmd,const char *memName) +static bool generateClassMemberLink(yyscan_t yyscanner, + CodeOutputInterface &ol, + MemberDef *xmd, + const char *memName) { + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; // extract class definition of the return type in order to resolve // a->b()->c() like call chains @@ -1124,22 +3093,22 @@ static bool generateClassMemberLink(CodeOutputInterface &ol,MemberDef *xmd,const // xmd->typeString(),xmd->argsString(), // xmd->getClassDef()->name().data()); - if (g_exampleBlock) + if (yyextra->exampleBlock) { QCString anchor; - anchor.sprintf("a%d",g_anchorCount); - //printf("addExampleFile(%s,%s,%s)\n",anchor.data(),g_exampleName.data(), - // g_exampleFile.data()); - if (xmd->addExample(anchor,g_exampleName,g_exampleFile)) + anchor.sprintf("a%d",yyextra->anchorCount); + //printf("addExampleFile(%s,%s,%s)\n",anchor.data(),yyextra->exampleName.data(), + // yyextra->exampleFile.data()); + if (xmd->addExample(anchor,yyextra->exampleName,yyextra->exampleFile)) { ol.writeCodeAnchor(anchor); - g_anchorCount++; + yyextra->anchorCount++; } } - const ClassDef *typeClass = stripClassName(removeAnonymousScopes(xmd->typeString()),xmd->getOuterScope()); + const ClassDef *typeClass = stripClassName(yyscanner,removeAnonymousScopes(xmd->typeString()),xmd->getOuterScope()); DBG_CTX((stderr,"%s -> typeName=%p\n",xmd->typeString(),typeClass)); - g_theCallContext.setScope(typeClass); + yyextra->theCallContext.setScope(typeClass); const Definition *xd = xmd->getOuterScope()==Doxygen::globalScope ? xmd->getFileDef() : xmd->getOuterScope(); @@ -1147,22 +3116,22 @@ static bool generateClassMemberLink(CodeOutputInterface &ol,MemberDef *xmd,const if (xd && xd->isLinkable()) { - //printf("g_currentDefiniton=%p g_currentMemberDef=%p xmd=%p g_insideBody=%d\n",g_currentDefinition,g_currentMemberDef,xmd,g_insideBody); + //printf("yyextra->currentDefinition=%p yyextra->currentMemberDef=%p xmd=%p yyextra->insideBody=%d\n",yyextra->currentDefinition,yyextra->currentMemberDef,xmd,yyextra->insideBody); if (xmd->templateMaster()) xmd = xmd->templateMaster(); if (xmd->isLinkable()) { // add usage reference - if (g_currentDefinition && g_currentMemberDef && - /*xmd!=g_currentMemberDef &&*/ g_insideBody && g_collectXRefs) + if (yyextra->currentDefinition && yyextra->currentMemberDef && + /*xmd!=yyextra->currentMemberDef &&*/ yyextra->insideBody && yyextra->collectXRefs) { - addDocCrossReference(g_currentMemberDef,xmd); + addDocCrossReference(yyextra->currentMemberDef,xmd); } // write the actual link - writeMultiLineCodeLink(ol,xmd,memName); - addToSearchIndex(memName); + writeMultiLineCodeLink(yyscanner,ol,xmd,memName); + addToSearchIndex(yyscanner,memName); return TRUE; } } @@ -1170,8 +3139,12 @@ static bool generateClassMemberLink(CodeOutputInterface &ol,MemberDef *xmd,const return FALSE; } -static bool generateClassMemberLink(CodeOutputInterface &ol,const Definition *def,const char *memName) +static bool generateClassMemberLink(yyscan_t yyscanner, + CodeOutputInterface &ol, + const Definition *def, + const char *memName) { + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; if (def && def->definitionType()==Definition::TypeClass) { const ClassDef *cd = dynamic_cast<const ClassDef*>(def); @@ -1179,16 +3152,16 @@ static bool generateClassMemberLink(CodeOutputInterface &ol,const Definition *de //printf("generateClassMemberLink(class=%s,member=%s)=%p\n",def->name().data(),memName,xmd); if (xmd) { - return generateClassMemberLink(ol,xmd,memName); + return generateClassMemberLink(yyscanner,ol,xmd,memName); } else { Definition *innerDef = cd->findInnerCompound(memName); if (innerDef) { - g_theCallContext.setScope(innerDef); - addToSearchIndex(memName); - writeMultiLineCodeLink(*g_code,innerDef,memName); + yyextra->theCallContext.setScope(innerDef); + addToSearchIndex(yyscanner,memName); + writeMultiLineCodeLink(yyscanner,*yyextra->code,innerDef,memName); return TRUE; } } @@ -1200,31 +3173,34 @@ static bool generateClassMemberLink(CodeOutputInterface &ol,const Definition *de Definition *innerDef = nd->findInnerCompound(memName); if (innerDef) { - g_theCallContext.setScope(innerDef); - addToSearchIndex(memName); - writeMultiLineCodeLink(*g_code,innerDef,memName); + yyextra->theCallContext.setScope(innerDef); + addToSearchIndex(yyscanner,memName); + writeMultiLineCodeLink(yyscanner,*yyextra->code,innerDef,memName); return TRUE; } } return FALSE; } -static void generateMemberLink(CodeOutputInterface &ol,const QCString &varName, - char *memName) +static void generateMemberLink(yyscan_t yyscanner, + CodeOutputInterface &ol, + const QCString &varName, + const char *memName) { + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; //printf("generateMemberLink(object=%s,mem=%s) classScope=%s\n", - // varName.data(),memName,g_classScope.data()); + // varName.data(),memName,yyextra->classScope.data()); if (varName.isEmpty()) return; // look for the variable in the current context - const ClassDef *vcd = g_theVarContext.findVariable(varName); + const ClassDef *vcd = yyextra->theVarContext.findVariable(varName); if (vcd) { if (vcd!=VariableContext::dummyContext) { //printf("Class found!\n"); - if (getLink(vcd->name(),memName,ol)) + if (getLink(yyscanner,vcd->name(),memName,ol)) { //printf("Found result!\n"); return; @@ -1234,7 +3210,7 @@ static void generateMemberLink(CodeOutputInterface &ol,const QCString &varName, BaseClassListIterator bcli(*vcd->baseClasses()); for ( ; bcli.current() ; ++bcli) { - if (getLink(bcli.current()->classDef->name(),memName,ol)) + if (getLink(yyscanner,bcli.current()->classDef->name(),memName,ol)) { //printf("Found result!\n"); return; @@ -1245,10 +3221,10 @@ static void generateMemberLink(CodeOutputInterface &ol,const QCString &varName, } else // variable not in current context, maybe it is in a parent context { - vcd = getResolvedClass(g_currentDefinition,g_sourceFileDef,g_classScope); + vcd = getResolvedClass(yyextra->currentDefinition,yyextra->sourceFileDef,yyextra->classScope); if (vcd && vcd->isLinkable()) { - //printf("Found class %s for variable '%s'\n",g_classScope.data(),varName.data()); + //printf("Found class %s for variable '%s'\n",yyextra->classScope.data(),varName.data()); MemberName *vmn=Doxygen::memberNameSDict->find(varName); if (vmn==0) { @@ -1270,10 +3246,10 @@ static void generateMemberLink(CodeOutputInterface &ol,const QCString &varName, vmd->getClassDef()==jcd) { //printf("Found variable type=%s\n",vmd->typeString()); - const ClassDef *mcd=stripClassName(vmd->typeString(),vmd->getOuterScope()); + const ClassDef *mcd=stripClassName(yyscanner,vmd->typeString(),vmd->getOuterScope()); if (mcd && mcd->isLinkable()) { - if (generateClassMemberLink(ol,mcd,memName)) return; + if (generateClassMemberLink(yyscanner,ol,mcd,memName)) return; } } } @@ -1291,10 +3267,10 @@ static void generateMemberLink(CodeOutputInterface &ol,const QCString &varName, vmd->getClassDef()==vcd) { //printf("Found variable type=%s\n",vmd->typeString()); - const ClassDef *mcd=stripClassName(vmd->typeString(),vmd->getOuterScope()); + const ClassDef *mcd=stripClassName(yyscanner,vmd->typeString(),vmd->getOuterScope()); if (mcd && mcd->isLinkable()) { - if (generateClassMemberLink(ol,mcd,memName)) return; + if (generateClassMemberLink(yyscanner,ol,mcd,memName)) return; } } } @@ -1302,29 +3278,31 @@ static void generateMemberLink(CodeOutputInterface &ol,const QCString &varName, } } // nothing found -> write result as is - codifyLines(memName); - addToSearchIndex(memName); + codifyLines(yyscanner,memName); + addToSearchIndex(yyscanner,memName); return; } -static void generatePHPVariableLink(CodeOutputInterface &ol,const char *varName) +static void generatePHPVariableLink(yyscan_t yyscanner,CodeOutputInterface &ol,const char *varName) { + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; QCString name = varName+7; // strip $this-> name.prepend("$"); - //printf("generatePHPVariableLink(%s) name=%s scope=%s\n",varName,name.data(),g_classScope.data()); - if (!getLink(g_classScope,name,ol,varName)) + //printf("generatePHPVariableLink(%s) name=%s scope=%s\n",varName,name.data(),yyextra->classScope.data()); + if (!getLink(yyscanner,yyextra->classScope,name,ol,varName)) { - codifyLines(varName); + codifyLines(yyscanner,varName); } } -static void generateFunctionLink(CodeOutputInterface &ol,const char *funcName) +static void generateFunctionLink(yyscan_t yyscanner,CodeOutputInterface &ol,const char *funcName) { + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; //CodeClassDef *ccd=0; ClassDef *ccd=0; - QCString locScope=g_classScope; + QCString locScope=yyextra->classScope; QCString locFunc=removeRedundantWhiteSpace(funcName); - if (g_insidePHP && locFunc.startsWith("self::")) locFunc=locFunc.mid(4); + if (yyextra->lang==SrcLangExt_PHP && locFunc.startsWith("self::")) locFunc=locFunc.mid(4); QCString funcScope; QCString funcWithScope=locFunc; QCString funcWithFullScope=locFunc; @@ -1332,15 +3310,15 @@ static void generateFunctionLink(CodeOutputInterface &ol,const char *funcName) DBG_CTX((stdout,"*** locScope=%s locFunc=%s\n",locScope.data(),locFunc.data())); int len=2; int i=locFunc.findRev("::"); - if (g_currentMemberDef && g_currentMemberDef->resolveAlias()->getClassDef() && - funcName==g_currentMemberDef->localName() && - g_currentMemberDef->getDefLine()==g_yyLineNr && - generateClassMemberLink(ol,g_currentMemberDef,funcName) + if (yyextra->currentMemberDef && yyextra->currentMemberDef->resolveAlias()->getClassDef() && + funcName==yyextra->currentMemberDef->localName() && + yyextra->currentMemberDef->getDefLine()==yyextra->yyLineNr && + generateClassMemberLink(yyscanner,ol,yyextra->currentMemberDef,funcName) ) { // special case where funcName is the name of a method that is also // defined on this line. In this case we can directly link to - // g_currentMemberDef, which is not only faster, but + // yyextra->currentMemberDef, which is not only faster, but // in case of overloaded methods, this will make sure that we link to // the correct method, and thereby get the correct reimplemented relations. // See also bug 549022. @@ -1381,49 +3359,50 @@ static void generateFunctionLink(CodeOutputInterface &ol,const char *funcName) funcWithFullScope = locScope+"::"+funcWithScope; } } - if (!fullScope.isEmpty() && (ccd=g_codeClassSDict->find(fullScope))) + if (!fullScope.isEmpty() && (ccd=yyextra->codeClassSDict->find(fullScope))) { - //printf("using classScope %s\n",g_classScope.data()); + //printf("using classScope %s\n",yyextra->classScope.data()); if (ccd->baseClasses()) { BaseClassListIterator bcli(*ccd->baseClasses()); for ( ; bcli.current() ; ++bcli) { - if (getLink(bcli.current()->classDef->name(),locFunc,ol,funcName)) + if (getLink(yyscanner,bcli.current()->classDef->name(),locFunc,ol,funcName)) { goto exit; } } } } - if (!locScope.isEmpty() && fullScope!=locScope && (ccd=g_codeClassSDict->find(locScope))) + if (!locScope.isEmpty() && fullScope!=locScope && (ccd=yyextra->codeClassSDict->find(locScope))) { - //printf("using classScope %s\n",g_classScope.data()); + //printf("using classScope %s\n",yyextra->classScope.data()); if (ccd->baseClasses()) { BaseClassListIterator bcli(*ccd->baseClasses()); for ( ; bcli.current() ; ++bcli) { - if (getLink(bcli.current()->classDef->name(),funcWithScope,ol,funcName)) + if (getLink(yyscanner,bcli.current()->classDef->name(),funcWithScope,ol,funcName)) { goto exit; } } } } - if (!getLink(locScope,funcWithScope,ol,funcName)) + if (!getLink(yyscanner,locScope,funcWithScope,ol,funcName)) { - generateClassOrGlobalLink(ol,funcName); + generateClassOrGlobalLink(yyscanner,ol,funcName); } exit: - g_forceTagReference.resize(0); + yyextra->forceTagReference.resize(0); return; } /*! counts the number of lines in the input */ -static int countLines() +static int countLines(yyscan_t yyscanner) { - const char *p=g_inputString; + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; + const char *p=yyextra->inputString; char c; int count=1; while ((c=*p)) @@ -1431,37 +3410,40 @@ static int countLines() p++ ; if (c=='\n') count++; } - if (p>g_inputString && *(p-1)!='\n') + if (p>yyextra->inputString && *(p-1)!='\n') { // last line does not end with a \n, so we add an extra // line and explicitly terminate the line after parsing. count++, - g_needsTermination=TRUE; + yyextra->needsTermination=TRUE; } return count; } -static void endFontClass() +static void endFontClass(yyscan_t yyscanner) { - if (g_currentFontClass) + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; + if (yyextra->currentFontClass) { - g_code->endFontClass(); - g_currentFontClass=0; + yyextra->code->endFontClass(); + yyextra->currentFontClass=0; } } -static void startFontClass(const char *s) +static void startFontClass(yyscan_t yyscanner,const char *s) { - endFontClass(); - g_code->startFontClass(s); - g_currentFontClass=s; + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; + endFontClass(yyscanner); + yyextra->code->startFontClass(s); + yyextra->currentFontClass=s; } //---------------------------------------------------------------------------- // recursively writes a linkified Objective-C method call -static void writeObjCMethodCall(ObjCCallCtx *ctx) +static void writeObjCMethodCall(yyscan_t yyscanner,ObjCCallCtx *ctx) { if (ctx==0) return; + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; char c; const char *p = ctx->format.data(); if (!ctx->methodName.isEmpty()) @@ -1472,22 +3454,22 @@ static void writeObjCMethodCall(ObjCCallCtx *ctx) { //printf("Looking for object=%s method=%s\n",ctx->objectTypeOrName.data(), // ctx->methodName.data()); - ClassDef *cd = g_theVarContext.findVariable(ctx->objectTypeOrName); + ClassDef *cd = yyextra->theVarContext.findVariable(ctx->objectTypeOrName); if (cd==0) // not a local variable { if (ctx->objectTypeOrName=="self") { - if (g_currentDefinition && - g_currentDefinition->definitionType()==Definition::TypeClass) + if (yyextra->currentDefinition && + yyextra->currentDefinition->definitionType()==Definition::TypeClass) { - ctx->objectType = dynamic_cast<ClassDef *>(g_currentDefinition); + ctx->objectType = dynamic_cast<ClassDef *>(yyextra->currentDefinition); } } else { ctx->objectType = getResolvedClass( - g_currentDefinition, - g_sourceFileDef, + yyextra->currentDefinition, + yyextra->sourceFileDef, ctx->objectTypeOrName, &ctx->method); } @@ -1500,15 +3482,15 @@ static void writeObjCMethodCall(ObjCCallCtx *ctx) else if (ctx->method==0) // search for class variable with the same name { //printf(" no\n"); - //printf("g_currentDefinition=%p\n",g_currentDefinition); - if (g_currentDefinition && - g_currentDefinition->definitionType()==Definition::TypeClass) + //printf("yyextra->currentDefinition=%p\n",yyextra->currentDefinition); + if (yyextra->currentDefinition && + yyextra->currentDefinition->definitionType()==Definition::TypeClass) { - ctx->objectVar = (dynamic_cast<ClassDef *>(g_currentDefinition))->getMemberByName(ctx->objectTypeOrName); + ctx->objectVar = (dynamic_cast<ClassDef *>(yyextra->currentDefinition))->getMemberByName(ctx->objectTypeOrName); //printf(" ctx->objectVar=%p\n",ctx->objectVar); if (ctx->objectVar) { - ctx->objectType = stripClassName(ctx->objectVar->typeString()); + ctx->objectType = stripClassName(yyscanner,ctx->objectVar->typeString(),yyextra->currentDefinition); //printf(" ctx->objectType=%p\n",ctx->objectType); if (ctx->objectType && !ctx->methodName.isEmpty()) { @@ -1539,7 +3521,7 @@ static void writeObjCMethodCall(ObjCCallCtx *ctx) char nc=*p++; if (nc=='$') // escaped $ { - g_code->codify("$"); + yyextra->code->codify("$"); } else // name fragment or reference to a nested call { @@ -1550,20 +3532,20 @@ static void writeObjCMethodCall(ObjCCallCtx *ctx) while (nc!=0 && isdigit(nc)) { refIdStr+=nc; nc=*p++; } p--; int refId=refIdStr.toInt(); - QCString *pName = g_nameDict.find(refId); + QCString *pName = yyextra->nameDict.find(refId); if (pName) { if (ctx->method && ctx->method->isLinkable()) { - writeMultiLineCodeLink(*g_code,ctx->method,pName->data()); - if (g_currentMemberDef && g_collectXRefs) + writeMultiLineCodeLink(yyscanner,*yyextra->code,ctx->method,pName->data()); + if (yyextra->currentMemberDef && yyextra->collectXRefs) { - addDocCrossReference(g_currentMemberDef,const_cast<MemberDef*>(ctx->method)); + addDocCrossReference(yyextra->currentMemberDef,const_cast<MemberDef*>(ctx->method)); } } else { - codifyLines(pName->data()); + codifyLines(yyscanner,pName->data()); } } else @@ -1578,15 +3560,15 @@ static void writeObjCMethodCall(ObjCCallCtx *ctx) while (nc!=0 && isdigit(nc)) { refIdStr+=nc; nc=*p++; } p--; int refId=refIdStr.toInt(); - QCString *pObject = g_objectDict.find(refId); + QCString *pObject = yyextra->objectDict.find(refId); if (pObject) { if (*pObject=="self") { - if (g_currentDefinition && - g_currentDefinition->definitionType()==Definition::TypeClass) + if (yyextra->currentDefinition && + yyextra->currentDefinition->definitionType()==Definition::TypeClass) { - ctx->objectType = dynamic_cast<ClassDef *>(g_currentDefinition); + ctx->objectType = dynamic_cast<ClassDef *>(yyextra->currentDefinition); if (ctx->objectType->categoryOf()) { ctx->objectType = ctx->objectType->categoryOf(); @@ -1596,16 +3578,16 @@ static void writeObjCMethodCall(ObjCCallCtx *ctx) ctx->method = ctx->objectType->getMemberByName(ctx->methodName); } } - startFontClass("keyword"); - codifyLines(pObject->data()); - endFontClass(); + startFontClass(yyscanner,"keyword"); + codifyLines(yyscanner,pObject->data()); + endFontClass(yyscanner); } else if (*pObject=="super") { - if (g_currentDefinition && - g_currentDefinition->definitionType()==Definition::TypeClass) + if (yyextra->currentDefinition && + yyextra->currentDefinition->definitionType()==Definition::TypeClass) { - ClassDef *cd = dynamic_cast<ClassDef *>(g_currentDefinition); + ClassDef *cd = dynamic_cast<ClassDef *>(yyextra->currentDefinition); if (cd->categoryOf()) { cd = cd->categoryOf(); @@ -1628,16 +3610,16 @@ static void writeObjCMethodCall(ObjCCallCtx *ctx) } } } - startFontClass("keyword"); - codifyLines(pObject->data()); - endFontClass(); + startFontClass(yyscanner,"keyword"); + codifyLines(yyscanner,pObject->data()); + endFontClass(yyscanner); } else if (ctx->objectVar && ctx->objectVar->isLinkable()) // object is class variable { - writeMultiLineCodeLink(*g_code,ctx->objectVar,pObject->data()); - if (g_currentMemberDef && g_collectXRefs) + writeMultiLineCodeLink(yyscanner,*yyextra->code,ctx->objectVar,pObject->data()); + if (yyextra->currentMemberDef && yyextra->collectXRefs) { - addDocCrossReference(g_currentMemberDef,const_cast<MemberDef*>(ctx->objectVar)); + addDocCrossReference(yyextra->currentMemberDef,const_cast<MemberDef*>(ctx->objectVar)); } } else if (ctx->objectType && @@ -1646,20 +3628,20 @@ static void writeObjCMethodCall(ObjCCallCtx *ctx) ) // object is class name { const ClassDef *cd = ctx->objectType; - writeMultiLineCodeLink(*g_code,cd,pObject->data()); + writeMultiLineCodeLink(yyscanner,*yyextra->code,cd,pObject->data()); } else // object still needs to be resolved { - const ClassDef *cd = getResolvedClass(g_currentDefinition, - g_sourceFileDef, *pObject); + const ClassDef *cd = getResolvedClass(yyextra->currentDefinition, + yyextra->sourceFileDef, *pObject); if (cd && cd->isLinkable()) { if (ctx->objectType==0) ctx->objectType=cd; - writeMultiLineCodeLink(*g_code,cd,pObject->data()); + writeMultiLineCodeLink(yyscanner,*yyextra->code,cd,pObject->data()); } else { - codifyLines(pObject->data()); + codifyLines(yyscanner,pObject->data()); } } } @@ -1675,10 +3657,10 @@ static void writeObjCMethodCall(ObjCCallCtx *ctx) while (nc!=0 && isdigit(nc)) { refIdStr+=nc; nc=*p++; } p--; int refId=refIdStr.toInt(); - ObjCCallCtx *ictx = g_contextDict.find(refId); + ObjCCallCtx *ictx = yyextra->contextDict.find(refId); if (ictx) // recurse into nested call { - writeObjCMethodCall(ictx); + writeObjCMethodCall(yyscanner,ictx); if (ictx->method) // link to nested call successfully { // get the ClassDef representing the method's return type @@ -1697,7 +3679,7 @@ static void writeObjCMethodCall(ObjCCallCtx *ctx) } else { - ctx->objectType = stripClassName(ictx->method->typeString()); + ctx->objectType = stripClassName(yyscanner,ictx->method->typeString(),yyextra->currentDefinition); if (ctx->objectType && !ctx->methodName.isEmpty()) { ctx->method = ctx->objectType->getMemberByName(ctx->methodName); @@ -1718,10 +3700,10 @@ static void writeObjCMethodCall(ObjCCallCtx *ctx) while (nc!=0 && isdigit(nc)) { refIdStr+=nc; nc=*p++; } p--; int refId=refIdStr.toInt(); - QCString *pWord = g_wordDict.find(refId); + QCString *pWord = yyextra->wordDict.find(refId); if (pWord) { - codifyLines(pWord->data()); + codifyLines(yyscanner,pWord->data()); } } else if (nc=='d') // comment block @@ -1731,12 +3713,12 @@ static void writeObjCMethodCall(ObjCCallCtx *ctx) while (nc!=0 && isdigit(nc)) { refIdStr+=nc; nc=*p++; } p--; int refId=refIdStr.toInt(); - QCString *pComment = g_commentDict.find(refId); + QCString *pComment = yyextra->commentDict.find(refId); if (pComment) { - startFontClass("comment"); - codifyLines(pComment->data()); - endFontClass(); + startFontClass(yyscanner,"comment"); + codifyLines(yyscanner,pComment->data()); + endFontClass(yyscanner); } } else // illegal marker @@ -1749,7 +3731,7 @@ static void writeObjCMethodCall(ObjCCallCtx *ctx) { char s[2]; s[0]=c;s[1]=0; - codifyLines(s); + codifyLines(yyscanner,s); } } //printf("%s %s]\n",ctx->objectTypeOrName.data(),ctx->methodName.data()); @@ -1760,46 +3742,51 @@ static void writeObjCMethodCall(ObjCCallCtx *ctx) // Replaces an Objective-C method name fragment s by a marker of the form // $n12, the number (12) can later be used as a key for obtaining the name -// fragment, from g_nameDict -static QCString escapeName(const char *s) +// fragment, from yyextra->nameDict +static QCString escapeName(yyscan_t yyscanner,const char *s) { + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; QCString result; - result.sprintf("$n%d",g_currentNameId); - g_nameDict.insert(g_currentNameId,new QCString(s)); - g_currentNameId++; + result.sprintf("$n%d",yyextra->currentNameId); + yyextra->nameDict.insert(yyextra->currentNameId,new QCString(s)); + yyextra->currentNameId++; return result; } -static QCString escapeObject(const char *s) +static QCString escapeObject(yyscan_t yyscanner,const char *s) { + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; QCString result; - result.sprintf("$o%d",g_currentObjId); - g_objectDict.insert(g_currentObjId,new QCString(s)); - g_currentObjId++; + result.sprintf("$o%d",yyextra->currentObjId); + yyextra->objectDict.insert(yyextra->currentObjId,new QCString(s)); + yyextra->currentObjId++; return result; } -static QCString escapeWord(const char *s) +static QCString escapeWord(yyscan_t yyscanner,const char *s) { + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; QCString result; - result.sprintf("$w%d",g_currentWordId); - g_wordDict.insert(g_currentWordId,new QCString(s)); - g_currentWordId++; + result.sprintf("$w%d",yyextra->currentWordId); + yyextra->wordDict.insert(yyextra->currentWordId,new QCString(s)); + yyextra->currentWordId++; return result; } -static QCString escapeComment(const char *s) +static QCString escapeComment(yyscan_t yyscanner,const char *s) { + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; QCString result; - result.sprintf("$d%d",g_currentCommentId); - g_commentDict.insert(g_currentCommentId,new QCString(s)); - g_currentCommentId++; + result.sprintf("$d%d",yyextra->currentCommentId); + yyextra->commentDict.insert(yyextra->currentCommentId,new QCString(s)); + yyextra->currentCommentId++; return result; } -static bool skipLanguageSpecificKeyword(const QCString &kw) +static bool skipLanguageSpecificKeyword(yyscan_t yyscanner,const QCString &kw) { - return g_insideCpp && (kw == "remove" || kw == "set" || kw == "get"); + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; + return yyextra->lang==SrcLangExt_Cpp && (kw == "remove" || kw == "set" || kw == "get"); } static bool isCastKeyword(const QCString &s) @@ -1810,1971 +3797,117 @@ static bool isCastKeyword(const QCString &s) return kw=="const_cast" || kw=="static_cast" || kw=="dynamic_cast" || kw=="reinterpret_cast"; } -/* ----------------------------------------------------------------- - */ -#undef YY_INPUT -#define YY_INPUT(buf,result,max_size) result=yyread(buf,max_size); - -static int yyread(char *buf,int max_size) +static int yyread(yyscan_t yyscanner,char *buf,int max_size) { - int c=0; - while( c < max_size && g_inputString[g_inputPosition] ) - { - *buf = g_inputString[g_inputPosition++] ; - c++; buf++; - } - return c; + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; + int inputPosition = yyextra->inputPosition; + const char *s = yyextra->inputString + yyextra->inputPosition; + int c=0; + while( c < max_size && *s ) + { + *buf++ = *s++; + c++; + } + yyextra->inputPosition += c; + return c; } -%} - -B [ \t] -BN [ \t\n\r] -ID "$"?[a-z_A-Z\x80-\xFF][a-z_A-Z0-9\x80-\xFF]* -SEP ("::"|"\\") -SCOPENAME ({SEP}{BN}*)?({ID}{BN}*{SEP}{BN}*)*("~"{BN}*)?{ID} -TEMPLIST "<"[^\"\}\{\(\)\/\n\>]*">" -SCOPETNAME (((({ID}{TEMPLIST}?){BN}*)?{SEP}{BN}*)*)((~{BN}*)?{ID}) -SCOPEPREFIX ({ID}{TEMPLIST}?{BN}*{SEP}{BN}*)+ -KEYWORD_OBJC ("@public"|"@private"|"@protected"|"@class"|"@implementation"|"@interface"|"@end"|"@selector"|"@protocol"|"@optional"|"@required"|"@throw"|"@synthesize"|"@property") -KEYWORD ("asm"|"__assume"|"auto"|"class"|"const"|"delete"|"enum"|"explicit"|"extern"|"false"|"friend"|"gcnew"|"gcroot"|"set"|"get"|"inline"|"internal"|"mutable"|"namespace"|"new"|"null"|"nullptr"|"override"|"operator"|"pin_ptr"|"private"|"protected"|"public"|"raise"|"register"|"remove"|"self"|"sizeof"|"static"|"struct"|"__super"|"function"|"template"|"generic"|"this"|"true"|"typedef"|"typeid"|"typename"|"union"|"using"|"virtual"|"volatile"|"abstract"|"final"|"import"|"synchronized"|"transient"|"alignas"|"alignof"|{KEYWORD_OBJC}) -FLOWKW ("break"|"catch"|"continue"|"default"|"do"|"else"|"finally"|"return"|"switch"|"throw"|"throws"|"@catch"|"@finally") -FLOWCONDITION ("case"|"for"|"foreach"|"for each"|"goto"|"if"|"try"|"while"|"@try") -TYPEKW ("bool"|"byte"|"char"|"double"|"float"|"int"|"long"|"object"|"short"|"signed"|"unsigned"|"void"|"wchar_t"|"size_t"|"boolean"|"id"|"SEL"|"string"|"nullptr") -TYPEKWSL ("LocalObject"|"Object"|"Value") -CASTKW ("const_cast"|"dynamic_cast"|"reinterpret_cast"|"static_cast") -CHARLIT (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^' \\\n]{1,4}"'")) -ARITHOP "+"|"-"|"/"|"*"|"%"|"--"|"++" -ASSIGNOP "="|"*="|"/="|"%="|"+="|"-="|"<<="|">>="|"&="|"^="|"|=" -LOGICOP "=="|"!="|">"|"<"|">="|"<="|"&&"|"||"|"!" -BITOP "&"|"|"|"^"|"<<"|">>"|"~" -OPERATOR {ARITHOP}|{ASSIGNOP}|{LOGICOP}|{BITOP} -RAWBEGIN (u|U|L|u8)?R\"[^ \t\(\)\\]{0,16}"(" -RAWEND ")"[^ \t\(\)\\]{0,16}\" - -%option noyywrap - -%x SkipString -%x SkipStringS -%x SkipVerbString -%x SkipCPP -%x SkipComment -%x SkipCxxComment -%x RemoveSpecialCComment -%x StripSpecialCComment -%x Body -%x FuncCall -%x MemberCall -%x MemberCall2 -%x SkipInits -%x ClassName -%x AlignAs -%x AlignAsEnd -%x PackageName -%x ClassVar -%x CppCliTypeModifierFollowup -%x Bases -%x SkipSharp -%x ReadInclude -%x TemplDecl -%x TemplCast -%x CallEnd -%x ObjCMethod -%x ObjCParams -%x ObjCParamType -%x ObjCCall -%x ObjCMName -%x ObjCSkipStr -%x ObjCCallComment -%x OldStyleArgs -%x UsingName -%x RawString -%x InlineInit - -%% - -<*>\x0d -<Body>^([ \t]*"#"[ \t]*("include"|"import")[ \t]*)("<"|"\"") { - startFontClass("preprocessor"); - g_code->codify(yytext); - BEGIN( ReadInclude ); - } -<Body>("@interface"|"@implementation"|"@protocol")[ \t\n]+ { - g_insideObjC=TRUE; - startFontClass("keyword"); - codifyLines(yytext); - endFontClass(); - if (!g_insideTemplate) - BEGIN( ClassName ); - } -<Body>(("public"|"private"){B}+)?("ref"|"value"|"interface"|"enum"){B}+("class"|"struct") { - if (g_insideTemplate) REJECT; - startFontClass("keyword"); - codifyLines(yytext); - endFontClass(); - BEGIN( ClassName ); - } -<Body>"property"|"event"/{BN}* { - if (g_insideTemplate) REJECT; - startFontClass("keyword"); - codifyLines(yytext); - endFontClass(); - } -<Body>(KEYWORD_CPPCLI_DATATYPE|("partial"{B}+)?"class"|"struct"|"union"|"namespace"|"interface"){B}+ { - startFontClass("keyword"); - codifyLines(yytext); - endFontClass(); - if (!g_insideTemplate) - BEGIN( ClassName ); - } -<Body>("package")[ \t\n]+ { - startFontClass("keyword"); - codifyLines(yytext); - endFontClass(); - BEGIN( PackageName ); - } -<ClassVar>\n { - if (!g_insideObjC) REJECT; - codifyLines(yytext); - BEGIN(Body); - } -<Body,ClassVar,Bases>"-"|"+" { - if (!g_insideObjC || g_insideBody) - { - g_code->codify(yytext); - } - else // Start of Objective-C method - { - //printf("Method!\n"); - g_code->codify(yytext); - BEGIN(ObjCMethod); - } - } -<ObjCMethod>":" { - g_code->codify(yytext); - BEGIN(ObjCParams); - } -<ObjCParams>"(" { - g_code->codify(yytext); - BEGIN(ObjCParamType); - } -<ObjCParams,ObjCMethod>";"|"{" { - g_code->codify(yytext); - if (*yytext=='{') - { - if (g_searchingForBody) - { - g_searchingForBody=FALSE; - g_insideBody=TRUE; - } - if (g_insideBody) g_bodyCurlyCount++; - if (!g_curClassName.isEmpty()) // valid class name - { - pushScope(g_curClassName); - DBG_CTX((stderr,"** scope stack push SCOPEBLOCK\n")); - g_scopeStack.push(SCOPEBLOCK); - } - } - g_type.resize(0); - g_name.resize(0); - BEGIN(Body); - } -<ObjCParams>{ID}{B}*":" { - g_code->codify(yytext); - } -<ObjCParamType>{TYPEKW} { - startFontClass("keywordtype"); - g_code->codify(yytext); - endFontClass(); - g_parmType=yytext; - } -<ObjCParamType>{ID} { - generateClassOrGlobalLink(*g_code,yytext); - g_parmType=yytext; - } -<ObjCParamType>")" { - g_code->codify(yytext); - BEGIN(ObjCParams); - } -<ObjCParams>{ID} { - g_code->codify(yytext); - g_parmName=yytext; - g_theVarContext.addVariable(g_parmType,g_parmName); - g_parmType.resize(0);g_parmName.resize(0); - } -<ObjCMethod,ObjCParams,ObjCParamType>{ID} { - generateClassOrGlobalLink(*g_code,yytext); - } -<ObjCMethod,ObjCParams,ObjCParamType>. { - g_code->codify(yytext); - } -<ObjCMethod,ObjCParams,ObjCParamType>\n { - codifyLines(yytext); - } -<ReadInclude>[^\n\"\>]+/(">"|"\"") { - //FileInfo *f; - bool ambig; - bool found=FALSE; - //QCString absPath = yytext; - //if (g_sourceFileDef && QDir::isRelativePath(absPath)) - //{ - // absPath = QDir::cleanDirPath(g_sourceFileDef->getPath()+"/"+absPath); - //} - FileDef *fd=findFileDef(Doxygen::inputNameDict,yytext,ambig); - //printf("looking for include %s -> %s fd=%p\n",yytext,absPath.data(),fd); - if (fd && fd->isLinkable()) - { - if (ambig) // multiple input files match the name - { - //printf("===== yes %s is ambiguous\n",yytext); - QCString name = QDir::cleanDirPath(yytext).utf8(); - if (!name.isEmpty() && g_sourceFileDef) - { - FileName *fn = Doxygen::inputNameDict->find(name); - if (fn) - { - FileNameIterator fni(*fn); - // for each include name - for (fni.toFirst();!found && (fd=fni.current());++fni) - { - // see if this source file actually includes the file - found = g_sourceFileDef->isIncluded(fd->absFilePath()); - //printf(" include file %s found=%d\n",fd->absFilePath().data(),found); - } - } - } - } - else // not ambiguous - { - found = TRUE; - } - } - //printf(" include file %s found=%d\n",fd ? fd->absFilePath().data() : "<none>",found); - if (found) - { - writeMultiLineCodeLink(*g_code,fd,yytext); - } - else - { - g_code->codify(yytext); - } - char c=yyinput(); - QCString text; - text+=c; - g_code->codify(text); - endFontClass(); - BEGIN( Body ); - } -<Body,Bases>^[ \t]*"#" { - startFontClass("preprocessor"); - g_lastSkipCppContext = YY_START; - g_code->codify(yytext); - BEGIN( SkipCPP ) ; - } -<SkipCPP>. { - g_code->codify(yytext); - } -<SkipCPP>[^\n\/\\]+ { - g_code->codify(yytext); - } -<SkipCPP>\\[\r]?\n { - codifyLines(yytext); - } -<SkipCPP>"//" { - g_code->codify(yytext); - } -<Body,FuncCall>"{" { - g_theVarContext.pushScope(); - - DBG_CTX((stderr,"** scope stack push INNERBLOCK\n")); - g_scopeStack.push(INNERBLOCK); - - if (g_searchingForBody) - { - g_searchingForBody=FALSE; - g_insideBody=TRUE; - } - g_code->codify(yytext); - if (g_insideBody) - { - g_bodyCurlyCount++; - } - g_type.resize(0); - g_name.resize(0); - BEGIN( Body ); - } -<Body,FuncCall,MemberCall,MemberCall2>"}" { - g_theVarContext.popScope(); - g_type.resize(0); - g_name.resize(0); - - int *scope = g_scopeStack.pop(); - DBG_CTX((stderr,"** scope stack pop SCOPEBLOCK=%d\n",scope==SCOPEBLOCK)); - if (scope==SCOPEBLOCK || scope==CLASSBLOCK) - { - popScope(); - } - - g_code->codify(yytext); - - DBG_CTX((stderr,"g_bodyCurlyCount=%d\n",g_bodyCurlyCount)); - if (--g_bodyCurlyCount<=0) - { - g_insideBody=FALSE; - g_currentMemberDef=0; - if (g_currentDefinition) - g_currentDefinition=g_currentDefinition->getOuterScope(); - } - BEGIN(Body); - } -<Body,ClassVar>"@end" { - //printf("End of objc scope fd=%s\n",g_sourceFileDef->name().data()); - if (g_sourceFileDef) - { - FileDef *fd=g_sourceFileDef; - g_insideObjC = fd->name().lower().right(2)==".m" || - fd->name().lower().right(3)==".mm"; - //printf("insideObjC=%d\n",g_insideObjC); - } - else - { - g_insideObjC = FALSE; - } - if (g_insideBody) - { - g_theVarContext.popScope(); - - int *scope = g_scopeStack.pop(); - DBG_CTX((stderr,"** scope stack pop SCOPEBLOCK=%d\n",scope==SCOPEBLOCK)); - if (scope==SCOPEBLOCK || scope==CLASSBLOCK) - { - popScope(); - } - g_insideBody=FALSE; - } - - startFontClass("keyword"); - g_code->codify(yytext); - endFontClass(); - - g_currentMemberDef=0; - if (g_currentDefinition) - g_currentDefinition=g_currentDefinition->getOuterScope(); - BEGIN(Body); - } -<ClassName,ClassVar>";" { - g_code->codify(yytext); - g_searchingForBody=FALSE; - BEGIN( Body ); - } -<ClassName,ClassVar>[*&^%]+ { - g_type=g_curClassName.copy(); - g_name.resize(0); - g_code->codify(yytext); - BEGIN( Body ); // variable of type struct * - } -<ClassName>"__declspec"{B}*"("{B}*{ID}{B}*")" { - startFontClass("keyword"); - g_code->codify(yytext); - endFontClass(); - } -<ClassName>{ID}("."{ID})* | -<ClassName>{ID}("::"{ID})* { - if(g_insideCS) - g_curClassName=substitute(yytext,".","::"); - else - g_curClassName=yytext; - addType(); - if (g_curClassName=="alignas") - { - startFontClass("keyword"); - g_code->codify(yytext); - endFontClass(); - BEGIN( AlignAs ); - } - else - { - generateClassOrGlobalLink(*g_code,yytext); - BEGIN( ClassVar ); - } - } -<AlignAs>"(" { - g_bracketCount=1; - g_code->codify(yytext); - BEGIN( AlignAsEnd ); - } -<AlignAs>\n { g_yyLineNr++; - codifyLines(yytext); - } -<AlignAs>. { g_code->codify(yytext); } -<AlignAsEnd>"(" { g_code->codify(yytext); - g_bracketCount++; - } -<AlignAsEnd>")" { - g_code->codify(yytext); - if (--g_bracketCount<=0) - { - BEGIN(ClassName); - } - } -<AlignAsEnd>\n { g_yyLineNr++; - codifyLines(yytext); - } -<AlignAsEnd>. { g_code->codify(yytext); } -<ClassName>{ID}("\\"{ID})* { // PHP namespace - g_curClassName=substitute(yytext,"\\","::"); - g_scopeStack.push(CLASSBLOCK); - pushScope(g_curClassName); - addType(); - generateClassOrGlobalLink(*g_code,yytext); - BEGIN( ClassVar ); - } -<ClassName>{ID}{B}*"("{ID}")" { // Obj-C category - g_curClassName=removeRedundantWhiteSpace(yytext); - g_scopeStack.push(CLASSBLOCK); - pushScope(g_curClassName); - addType(); - generateClassOrGlobalLink(*g_code,yytext); - BEGIN( ClassVar ); - } -<PackageName>{ID}("."{ID})* { - g_curClassName=substitute(yytext,".","::"); - //printf("found package: %s\n",g_curClassName.data()); - addType(); - codifyLines(yytext); - } -<ClassVar>"=" { - unput(*yytext); - BEGIN( Body ); - } -<ClassVar>("extends"|"implements") { // Java, Slice - startFontClass("keyword"); - codifyLines(yytext); - endFontClass(); - g_curClassBases.clear(); - BEGIN( Bases ); - } -<ClassVar>("sealed"|"abstract")/{BN}*(":"|"{") { - DBG_CTX((stderr,"***** C++/CLI modifier %s on g_curClassName=%s\n",yytext,g_curClassName.data())); - startFontClass("keyword"); - codifyLines(yytext); - endFontClass(); - BEGIN( CppCliTypeModifierFollowup ); - } -<ClassVar>{ID} { - g_type = g_curClassName.copy(); - g_name = yytext; - if (g_insideBody) - { - g_theVarContext.addVariable(g_type,g_name); - } - generateClassOrGlobalLink(*g_code,yytext); - } -<ClassName,ClassVar,CppCliTypeModifierFollowup>{B}*":"{B}* { - codifyLines(yytext); - g_curClassBases.clear(); - BEGIN( Bases ); - } -<PackageName>[ \t]*";" | -<Bases>^{B}*/"@"{ID} | // Objective-C interface -<Bases,ClassName,ClassVar,CppCliTypeModifierFollowup>{B}*"{"{B}* { - g_theVarContext.pushScope(); - g_code->codify(yytext); - if (YY_START==ClassVar && g_curClassName.isEmpty()) - { - g_curClassName = g_name.copy(); - } - if (g_searchingForBody) - { - g_searchingForBody=FALSE; - g_insideBody=TRUE; - } - if (g_insideBody) g_bodyCurlyCount++; - if (!g_curClassName.isEmpty()) // valid class name - { - DBG_CTX((stderr,"** scope stack push CLASSBLOCK\n")); - g_scopeStack.push(CLASSBLOCK); - pushScope(g_curClassName); - DBG_CTX((stderr,"***** g_curClassName=%s\n",g_curClassName.data())); - if (getResolvedClass(g_currentDefinition,g_sourceFileDef,g_curClassName)==0) - { - DBG_CTX((stderr,"Adding new class %s\n",g_curClassName.data())); - ClassDef *ncd=createClassDef("<code>",1,1, - g_curClassName,ClassDef::Class,0,0,FALSE); - g_codeClassSDict->append(g_curClassName,ncd); - // insert base classes. - char *s=g_curClassBases.first(); - while (s) - { - const ClassDef *bcd=g_codeClassSDict->find(s); - if (bcd==0) bcd=getResolvedClass(g_currentDefinition,g_sourceFileDef,s); - if (bcd && bcd!=ncd) - { - ncd->insertBaseClass(const_cast<ClassDef*>(bcd),s,Public,Normal); - } - s=g_curClassBases.next(); - } - } - //printf("g_codeClassList.count()=%d\n",g_codeClassList.count()); - } - else // not a class name -> assume inner block - { - DBG_CTX((stderr,"** scope stack push INNERBLOCK\n")); - g_scopeStack.push(INNERBLOCK); - } - g_curClassName.resize(0); - g_curClassBases.clear(); - BEGIN( Body ); - } -<Bases>"virtual"|"public"|"protected"|"private"|"@public"|"@private"|"@protected" { - startFontClass("keyword"); - g_code->codify(yytext); - endFontClass(); - } -<Bases>{SEP}?({ID}{SEP})*{ID} { - DBG_CTX((stderr,"%s:addBase(%s)\n",g_curClassName.data(),yytext)); - g_curClassBases.inSort(yytext); - generateClassOrGlobalLink(*g_code,yytext); - } -<Bases>"<" { - g_code->codify(yytext); - if (!g_insideObjC) - { - g_sharpCount=1; - BEGIN ( SkipSharp ); - } - else - { - g_insideProtocolList=TRUE; - } - } -<Bases>">" { - g_code->codify(yytext); - g_insideProtocolList=FALSE; - } -<SkipSharp>"<" { - g_code->codify(yytext); - ++g_sharpCount; - } -<SkipSharp>">" { - g_code->codify(yytext); - if (--g_sharpCount<=0) - BEGIN ( Bases ); - } -<SkipSharp>"\"" { - g_code->codify(yytext); - g_lastStringContext=YY_START; - BEGIN(SkipString); - } -<SkipSharp>"\'" { - g_code->codify(yytext); - g_lastStringContext=YY_START; - BEGIN(SkipStringS); - } -<Bases>"(" { - g_code->codify(yytext); - g_sharpCount=1; - BEGIN ( SkipSharp ); - } -<SkipSharp>"(" { - g_code->codify(yytext); - ++g_sharpCount; - } -<SkipSharp>")" { - g_code->codify(yytext); - if (--g_sharpCount<=0) - BEGIN ( Bases ); - } - - -<Bases>"," { - g_code->codify(yytext); - } - - -<Body>{SCOPEPREFIX}?"operator"{B}*"()"{B}*/"(" { - addType(); - generateFunctionLink(*g_code,yytext); - g_bracketCount=0; - g_args.resize(0); - g_name+=yytext; - BEGIN( FuncCall ); - } -<Body>{SCOPEPREFIX}?"operator"/"(" { - addType(); - generateFunctionLink(*g_code,yytext); - g_bracketCount=0; - g_args.resize(0); - g_name+=yytext; - BEGIN( FuncCall ); - } -<Body>{SCOPEPREFIX}?"operator"[^a-z_A-Z0-9\(\n]+/"(" { - addType(); - generateFunctionLink(*g_code,yytext); - g_bracketCount=0; - g_args.resize(0); - g_name+=yytext; - BEGIN( FuncCall ); - } -<Body,TemplDecl>("template"|"generic")/([^a-zA-Z0-9]) { - startFontClass("keyword"); - codifyLines(yytext); - endFontClass(); - g_insideTemplate=TRUE; - g_sharpCount=0; - } -<Body>"using"{BN}+"namespace"{BN}+ { - startFontClass("keyword"); - codifyLines(yytext); - endFontClass(); - BEGIN(UsingName); - } -<UsingName>{ID}("::"{ID})* { addUsingDirective(yytext); - generateClassOrGlobalLink(*g_code,yytext); - DBG_CTX((stderr,"** scope stack push CLASSBLOCK\n")); - g_scopeStack.push(CLASSBLOCK); - pushScope(yytext); - BEGIN(Body); - } -<UsingName>\n { codifyLines(yytext); BEGIN(Body); } -<UsingName>. { codifyLines(yytext); BEGIN(Body); } -<Body,FuncCall>"$"?"this"("->"|".") { g_code->codify(yytext); // this-> for C++, this. for C# - g_prefixed_with_this_keyword = TRUE; - } -<Body>{KEYWORD}/([^a-z_A-Z0-9]) { - if (g_insideJava && qstrcmp("internal",yytext) ==0) REJECT; - if (skipLanguageSpecificKeyword(yytext)) REJECT; - startFontClass("keyword"); - codifyLines(yytext); - if (QCString(yytext)=="typedef") - { - addType(); - g_name+=yytext; - } - endFontClass(); - } -<Body>{KEYWORD}/{B}* { - if (skipLanguageSpecificKeyword(yytext)) REJECT; - startFontClass("keyword"); - codifyLines(yytext); - endFontClass(); - } -<Body>{KEYWORD}/{BN}*"(" { - if (skipLanguageSpecificKeyword(yytext)) REJECT; - startFontClass("keyword"); - codifyLines(yytext); - endFontClass(); - g_name.resize(0);g_type.resize(0); - } -<FuncCall>"in"/{BN}* { - if (!g_inForEachExpression) REJECT; - startFontClass("keywordflow"); - codifyLines(yytext); - endFontClass(); - // insert the variable in the parent scope, see bug 546158 - g_theVarContext.popScope(); - g_theVarContext.addVariable(g_parmType,g_parmName); - g_theVarContext.pushScope(); - g_name.resize(0);g_type.resize(0); - } -<Body>{FLOWKW}/{BN}*"(" { - startFontClass("keywordflow"); - codifyLines(yytext); - endFontClass(); - g_name.resize(0);g_type.resize(0); - g_inForEachExpression = (qstrcmp(yytext,"for each")==0 || qstrcmp(yytext, "foreach")==0); - BEGIN(FuncCall); - } -<Body>{FLOWCONDITION}/{BN}*"(" { - if (g_currentMemberDef && g_currentMemberDef->isFunction()) - { - g_currentMemberDef->incrementFlowKeyWordCount(); - } - startFontClass("keywordflow"); - codifyLines(yytext); - endFontClass(); - g_name.resize(0);g_type.resize(0); - g_inForEachExpression = (strcmp(yytext,"for each")==0 || strcmp(yytext, "foreach")==0); - BEGIN(FuncCall); - } -<Body>{FLOWKW}/([^a-z_A-Z0-9]) { - startFontClass("keywordflow"); - codifyLines(yytext); - endFontClass(); - if (g_inFunctionTryBlock && (qstrcmp(yytext,"catch")==0 || qstrcmp(yytext,"finally")==0)) - { - g_inFunctionTryBlock=FALSE; - } - } -<Body>{FLOWCONDITION}/([^a-z_A-Z0-9]) { - if (g_currentMemberDef && g_currentMemberDef->isFunction()) - { - g_currentMemberDef->incrementFlowKeyWordCount(); - } - startFontClass("keywordflow"); - codifyLines(yytext); - endFontClass(); - if (g_inFunctionTryBlock && (strcmp(yytext,"catch")==0 || strcmp(yytext,"finally")==0)) - { - g_inFunctionTryBlock=FALSE; - } - } -<Body>{FLOWKW}/{B}* { - startFontClass("keywordflow"); - codifyLines(yytext); - endFontClass(); - } -<Body>{FLOWCONDITION}/{B}* { - if (g_currentMemberDef && g_currentMemberDef->isFunction()) - { - g_currentMemberDef->incrementFlowKeyWordCount(); - } - startFontClass("keywordflow"); - codifyLines(yytext); - endFontClass(); - } -<Body>"*"{B}*")" { // end of cast? - g_code->codify(yytext); - g_theCallContext.popScope(g_name, g_type); - g_bracketCount--; - g_parmType = g_name; - BEGIN(FuncCall); - } -<Body>[\\|\)\+\-\/\%\~\!] { - g_code->codify(yytext); - g_name.resize(0);g_type.resize(0); - if (*yytext==')') - { - g_theCallContext.popScope(g_name, g_type); - g_bracketCount--; - BEGIN(FuncCall); - } - } -<Body,TemplDecl,ObjCMethod>{TYPEKW}/{B}* { - startFontClass("keywordtype"); - g_code->codify(yytext); - endFontClass(); - addType(); - g_name+=yytext; - } -<Body,TemplDecl,ObjCMethod>{TYPEKWSL}/{B}* { - if (!g_insideSlice) - { - REJECT; - } - else - { - startFontClass("keywordtype"); - g_code->codify(yytext); - endFontClass(); - addType(); - g_name+=yytext; - } - } -<Body>"generic"/{B}*"<"[^\n\/\-\.\{\"\>]*">"{B}* { - startFontClass("keyword"); - g_code->codify(yytext); - endFontClass(); - g_sharpCount=0; - BEGIN(TemplDecl); - } -<Body>"template"/{B}*"<"[^\n\/\-\.\{\"\>]*">"{B}* { // template<...> - startFontClass("keyword"); - g_code->codify(yytext); - endFontClass(); - g_sharpCount=0; - BEGIN(TemplDecl); - } -<TemplDecl>"class"|"typename" { - startFontClass("keyword"); - codifyLines(yytext); - endFontClass(); - } -<TemplDecl>"<" { - g_code->codify(yytext); - g_sharpCount++; - } -<TemplDecl>">" { - g_code->codify(yytext); - g_sharpCount--; - if (g_sharpCount<=0) - { - BEGIN(Body); - } - } -<TemplCast>">" { - startFontClass("keyword"); - codifyLines(yytext); - endFontClass(); - BEGIN( g_lastTemplCastContext ); - } -<TemplCast>{ID}("::"{ID})* { - generateClassOrGlobalLink(*g_code,yytext); - } -<TemplCast>("const"|"volatile"){B}* { - startFontClass("keyword"); - codifyLines(yytext); - endFontClass(); - } -<TemplCast>[*^]* { - codifyLines(yytext); - } -<Body,MemberCall2,FuncCall>{CASTKW}{B}*"<" { // static_cast<T>( - startFontClass("keyword"); - codifyLines(yytext); - endFontClass(); - g_lastTemplCastContext = YY_START; - BEGIN(TemplCast); - } -<Body>"$this->"{SCOPENAME}/{BN}*[;,)\]] { // PHP member variable - addType(); - generatePHPVariableLink(*g_code,yytext); - g_name+=yytext+7; - } -<Body,TemplCast>{SCOPENAME}{B}*"<"[^\n\/\-\.\{\"\>\(]*">"("::"{ID})*/{B}* { // A<T> *pt; - if (isCastKeyword(yytext) && YY_START==Body) - { - REJECT; - } - addType(); - generateClassOrGlobalLink(*g_code,yytext); - g_name+=yytext; - } -<Body>{SCOPENAME}/{BN}*[:;,)\]] { // "int var;" or "var, var2" or "debug(f) macro" , or int var : 5; - addType(); - // changed this to generateFunctionLink, see bug 624514 - //generateClassOrGlobalLink(*g_code,yytext,FALSE,TRUE); - generateFunctionLink(*g_code,yytext); - g_name+=yytext; - } -<Body>{SCOPENAME}/{B}* { // p->func() - addType(); - generateClassOrGlobalLink(*g_code,yytext); - g_name+=yytext; - } -<Body>"("{B}*("*"{B}*)+{SCOPENAME}*{B}*")"/{B}* { // (*p)->func() but not "if (p) ..." - g_code->codify(yytext); - int s=0;while (s<(int)yyleng && !isId(yytext[s])) s++; - int e=(int)yyleng-1;while (e>=0 && !isId(yytext[e])) e--; - QCString varname = ((QCString)yytext).mid(s,e-s+1); - addType(); - g_name=varname; - } -<Body>{SCOPETNAME}{B}*"<"[^\n\/\-\.\{\"\>]*">"/{BN}*"(" | -<Body>{SCOPETNAME}/{BN}*"(" { // a() or c::a() or t<A,B>::a() or A\B\foo() - if (isCastKeyword(yytext)) - { - REJECT; - } - addType(); - generateFunctionLink(*g_code,yytext); - g_bracketCount=0; - g_args.resize(0); - g_name+=yytext; - BEGIN( FuncCall ); - } -<FuncCall,Body,MemberCall,MemberCall2,SkipInits,InlineInit>{RAWBEGIN} { - QCString text=yytext; - int i=text.find('R'); - g_code->codify(text.left(i+1)); - startFontClass("stringliteral"); - g_code->codify(yytext+i+1); - g_lastStringContext=YY_START; - g_inForEachExpression = FALSE; - g_delimiter = yytext+i+2; - g_delimiter=g_delimiter.left(g_delimiter.length()-1); - BEGIN( RawString ); - } -<FuncCall,Body,MemberCall,MemberCall2,SkipInits,InlineInit>\" { - startFontClass("stringliteral"); - g_code->codify(yytext); - g_lastStringContext=YY_START; - g_inForEachExpression = FALSE; - BEGIN( SkipString ); - } -<FuncCall,Body,MemberCall,MemberCall2,SkipInits,InlineInit>\' { - startFontClass("stringliteral"); - g_code->codify(yytext); - g_lastStringContext=YY_START; - g_inForEachExpression = FALSE; - BEGIN( SkipStringS ); - } -<SkipString>[^\"\\\r\n]* { - g_code->codify(yytext); - } -<SkipStringS>[^\'\\\r\n]* { - g_code->codify(yytext); - } -<SkipString,SkipStringS>"//"|"/*" { - g_code->codify(yytext); - } -<SkipString>@?\" { - g_code->codify(yytext); - endFontClass(); - BEGIN( g_lastStringContext ); - } -<SkipStringS>\' { - g_code->codify(yytext); - endFontClass(); - BEGIN( g_lastStringContext ); - } -<SkipString,SkipStringS>\\. { - g_code->codify(yytext); - } -<RawString>{RAWEND} { - g_code->codify(yytext); - QCString delimiter = yytext+1; - delimiter=delimiter.left(delimiter.length()-1); - if (delimiter==g_delimiter) - { - BEGIN( g_lastStringContext ); - } - } -<RawString>[^)\n]+ { g_code->codify(yytext); } -<RawString>. { g_code->codify(yytext); } -<RawString>\n { codifyLines(yytext); } -<SkipVerbString>[^"\n]+ { - g_code->codify(yytext); - } -<SkipVerbString>\"\" { // escaped quote - g_code->codify(yytext); - } -<SkipVerbString>\" { // end of string - g_code->codify(yytext); - endFontClass(); - BEGIN( g_lastVerbStringContext ); - } -<SkipVerbString>. { - g_code->codify(yytext); - } -<SkipVerbString>\n { - codifyLines(yytext); - } -<Body>":" { - g_code->codify(yytext); - g_name.resize(0);g_type.resize(0); - } -<Body>"<" { - if (g_insideTemplate) - { - g_sharpCount++; - } - g_code->codify(yytext); - } -<Body>">" { - if (g_insideTemplate) - { - if (--g_sharpCount<=0) - { - g_insideTemplate=FALSE; - } - } - g_code->codify(yytext); - } -<Body,MemberCall,MemberCall2,FuncCall>"'"((\\0[Xx0-9]+)|(\\.)|(.))"'" { - startFontClass("charliteral"); - g_code->codify(yytext); - endFontClass(); - } -<Body>"."|"->" { - if (yytext[0]=='-') // -> could be overloaded - { - updateCallContextForSmartPointer(); - } - g_code->codify(yytext); - g_memCallContext = YY_START; - BEGIN( MemberCall ); - } -<MemberCall>{SCOPETNAME}/{BN}*"(" { - if (g_theCallContext.getScope()) - { - if (!generateClassMemberLink(*g_code,g_theCallContext.getScope(),yytext)) - { - g_code->codify(yytext); - addToSearchIndex(yytext); - } - g_name.resize(0); - } - else - { - g_code->codify(yytext); - addToSearchIndex(yytext); - g_name.resize(0); - } - g_type.resize(0); - if (g_memCallContext==Body) - { - BEGIN(FuncCall); - } - else - { - BEGIN(g_memCallContext); - } - } -<MemberCall>{SCOPENAME}/{B}* { - if (g_theCallContext.getScope()) - { - DBG_CTX((stderr,"g_theCallContext.getClass()=%p\n",g_theCallContext.getScope())); - if (!generateClassMemberLink(*g_code,g_theCallContext.getScope(),yytext)) - { - g_code->codify(yytext); - addToSearchIndex(yytext); - } - g_name.resize(0); - } - else - { - DBG_CTX((stderr,"no class context!\n")); - g_code->codify(yytext); - addToSearchIndex(yytext); - g_name.resize(0); - } - g_type.resize(0); - BEGIN(g_memCallContext); - } -<Body>[,=;\[] { - if (g_insideObjC && *yytext=='[') - { - //printf("Found start of ObjC call!\n"); - // start of a method call - g_contextDict.setAutoDelete(TRUE); - g_nameDict.setAutoDelete(TRUE); - g_objectDict.setAutoDelete(TRUE); - g_wordDict.setAutoDelete(TRUE); - g_commentDict.setAutoDelete(TRUE); - g_contextDict.clear(); - g_nameDict.clear(); - g_objectDict.clear(); - g_wordDict.clear(); - g_commentDict.clear(); - g_currentCtxId = 0; - g_currentNameId = 0; - g_currentObjId = 0; - g_currentCtx = 0; - g_braceCount = 0; - unput('['); - BEGIN(ObjCCall); - } - else - { - g_code->codify(yytext); - g_saveName = g_name.copy(); - g_saveType = g_type.copy(); - if (*yytext!='[' && !g_type.isEmpty()) - { - //printf("g_scopeStack.bottom()=%p\n",g_scopeStack.bottom()); - //if (g_scopeStack.top()!=CLASSBLOCK) // commented out for bug731363 - { - //printf("AddVariable: '%s' '%s' context=%d\n", - // g_type.data(),g_name.data(),g_theVarContext.count()); - g_theVarContext.addVariable(g_type,g_name); - } - g_name.resize(0); - } - if (*yytext==';' || *yytext=='=') - { - g_type.resize(0); - g_name.resize(0); - } - else if (*yytext=='[') - { - g_theCallContext.pushScope(g_name, g_type); - } - g_args.resize(0); - g_parmType.resize(0); - g_parmName.resize(0); - } - } - /* -<ObjCMemberCall>{ID} { - if (qstrcmp(yytext,"self")==0 || qstrcmp(yytext,"super")==0) - { - // TODO: get proper base class for "super" - g_theCallContext.setClass(getClass(g_curClassName)); - startFontClass("keyword"); - g_code->codify(yytext); - endFontClass(); - } - else - { - generateClassOrGlobalLink(*g_code,yytext); - } - g_name.resize(0); - BEGIN(ObjCMemberCall2); - } -<ObjCMemberCall>"[" { - g_code->codify(yytext); - g_theCallContext.pushScope(g_name, g_type); - } -<ObjCMemberCall2>{ID}":"? { - g_name+=yytext; - if (g_theCallContext.getClass()) - { - //printf("Calling method %s\n",g_name.data()); - if (!generateClassMemberLink(*g_code,g_theCallContext.getClass(),g_name)) - { - g_code->codify(yytext); - addToSearchIndex(g_name); - } - } - else - { - g_code->codify(yytext); - addToSearchIndex(g_name); - } - g_name.resize(0); - BEGIN(ObjCMemberCall3); - } -<ObjCMemberCall2,ObjCMemberCall3>"]" { - g_theCallContext.popScope(g_name, g_type); - g_code->codify(yytext); - BEGIN(Body); - } - */ -<ObjCCall,ObjCMName>"["|"{" { - saveObjCContext(); - g_currentCtx->format+=*yytext; - BEGIN(ObjCCall); - //printf("open\n"); - } -<ObjCCall,ObjCMName>"]"|"}" { - g_currentCtx->format+=*yytext; - restoreObjCContext(); - BEGIN(ObjCMName); - if (g_currentCtx==0) - { - // end of call - writeObjCMethodCall(g_contextDict.find(0)); - BEGIN(Body); - } - //printf("close\n"); - } -<ObjCCall,ObjCMName>"//".* { - g_currentCtx->format+=escapeComment(yytext); - } -<ObjCCall,ObjCMName>"/*" { - g_lastObjCCallContext = YY_START; - g_currentCtx->comment=yytext; - BEGIN(ObjCCallComment); - } -<ObjCCallComment>"*/" { - g_currentCtx->comment+=yytext; - g_currentCtx->format+=escapeComment(g_currentCtx->comment); - BEGIN(g_lastObjCCallContext); - } -<ObjCCallComment>[^*\n]+ { g_currentCtx->comment+=yytext; } -<ObjCCallComment>"//"|"/*" { g_currentCtx->comment+=yytext; } -<ObjCCallComment>\n { g_currentCtx->comment+=*yytext; } -<ObjCCallComment>. { g_currentCtx->comment+=*yytext; } -<ObjCCall>{ID} { - g_currentCtx->format+=escapeObject(yytext); - if (g_braceCount==0) - { - g_currentCtx->objectTypeOrName=yytext; - //printf("new type=%s\n",g_currentCtx->objectTypeOrName.data()); - BEGIN(ObjCMName); - } - } -<ObjCMName>{ID}/{BN}*"]" { - if (g_braceCount==0 && - g_currentCtx->methodName.isEmpty()) - { - g_currentCtx->methodName=yytext; - g_currentCtx->format+=escapeName(yytext); - } - else - { - g_currentCtx->format+=escapeWord(yytext); - } - } -<ObjCMName>{ID}/{BN}*":" { - if (g_braceCount==0) - { - g_currentCtx->methodName+=yytext; - g_currentCtx->methodName+=":"; - } - g_currentCtx->format+=escapeName(yytext); - } -<ObjCSkipStr>[^\n\"$\\]* { g_currentCtx->format+=yytext; } -<ObjCSkipStr>\\. { g_currentCtx->format+=yytext; } -<ObjCSkipStr>"\"" { g_currentCtx->format+=yytext; - BEGIN(g_lastStringContext); - } -<ObjCCall,ObjCMName>{CHARLIT} { g_currentCtx->format+=yytext; } -<ObjCCall,ObjCMName>"@"?"\"" { g_currentCtx->format+=yytext; - g_lastStringContext=YY_START; - BEGIN(ObjCSkipStr); - } -<ObjCCall,ObjCMName,ObjCSkipStr>"$" { g_currentCtx->format+="$$"; } -<ObjCCall,ObjCMName>"(" { g_currentCtx->format+=*yytext; g_braceCount++; } -<ObjCCall,ObjCMName>")" { g_currentCtx->format+=*yytext; g_braceCount--; } -<ObjCSkipStr>"@"/"\"" { // needed to prevent matching the global rule (for C#) - g_currentCtx->format+=yytext; - } -<ObjCCall,ObjCMName,ObjCSkipStr>{ID} { g_currentCtx->format+=escapeWord(yytext); } -<ObjCCall,ObjCMName,ObjCSkipStr>. { g_currentCtx->format+=*yytext; } -<ObjCCall,ObjCMName,ObjCSkipStr>\n { g_currentCtx->format+=*yytext; } - -<Body>"]" { - g_theCallContext.popScope(g_name, g_type); - g_code->codify(yytext); - // TODO: nested arrays like: a[b[0]->func()]->func() - g_name = g_saveName.copy(); - g_type = g_saveType.copy(); - } -<Body>[0-9]+ { - g_code->codify(yytext); - } -<Body>[0-9]+[xX][0-9A-Fa-f]+ { - g_code->codify(yytext); - } -<MemberCall2,FuncCall>{KEYWORD}/([^a-z_A-Z0-9]) { - //addParmType(); - //g_parmName=yytext; - if (skipLanguageSpecificKeyword(yytext)) REJECT; - startFontClass("keyword"); - g_code->codify(yytext); - endFontClass(); - } -<MemberCall2,FuncCall,OldStyleArgs,TemplCast>{TYPEKW}/([^a-z_A-Z0-9]) { - addParmType(); - g_parmName=yytext; - startFontClass("keywordtype"); - g_code->codify(yytext); - endFontClass(); - } -<MemberCall2,FuncCall,OldStyleArgs,TemplCast>{TYPEKWSL}/([^a-z_A-Z0-9]) { - if (!g_insideSlice) - { - REJECT; - } - else - { - addParmType(); - g_parmName=yytext; - startFontClass("keywordtype"); - g_code->codify(yytext); - endFontClass(); - } - } -<MemberCall2,FuncCall>{FLOWKW}/([^a-z_A-Z0-9]) { - addParmType(); - g_parmName=yytext; - startFontClass("keywordflow"); - g_code->codify(yytext); - endFontClass(); - } -<MemberCall2,FuncCall>{FLOWCONDITION}/([^a-z_A-Z0-9]) { - if (g_currentMemberDef && g_currentMemberDef->isFunction()) - { - g_currentMemberDef->incrementFlowKeyWordCount(); - } - addParmType(); - g_parmName=yytext; - startFontClass("keywordflow"); - g_code->codify(yytext); - endFontClass(); - } -<MemberCall2,FuncCall>{ID}(({B}*"<"[^\n\[\](){}<>]*">")?({B}*"::"{B}*{ID})?)* { - if (isCastKeyword(yytext)) - { - REJECT; - } - addParmType(); - g_parmName=yytext; - generateClassOrGlobalLink(*g_code,yytext,!g_insideBody); - } -<FuncCall>";" { // probably a cast, not a function call - g_code->codify(yytext); - g_inForEachExpression = FALSE; - BEGIN( Body ); - } -<MemberCall2,FuncCall>, { - g_code->codify(yytext); - g_theVarContext.addVariable(g_parmType,g_parmName); - g_parmType.resize(0);g_parmName.resize(0); - } -<MemberCall2,FuncCall>"{" { - if (g_bracketCount>0) - { - g_code->codify(yytext); - g_skipInlineInitContext=YY_START; - g_curlyCount=0; - BEGIN(InlineInit); - } - else - { - REJECT; - } - } -<InlineInit>"{" { g_curlyCount++; - g_code->codify(yytext); - } -<InlineInit>"}" { - g_code->codify(yytext); - if (--g_curlyCount<=0) - { - BEGIN(g_skipInlineInitContext); - } - } -<InlineInit>\n { - codifyLines(yytext); - } -<InlineInit>. { - g_code->codify(yytext); - } -<MemberCall2,FuncCall>"(" { - g_parmType.resize(0);g_parmName.resize(0); - g_code->codify(yytext); - g_bracketCount++; - g_theCallContext.pushScope(g_name, g_type); - if (YY_START==FuncCall && !g_insideBody) - { - g_theVarContext.pushScope(); - } - } -<MemberCall2,FuncCall>{OPERATOR} { // operator - if (qstrcmp(yytext,"*") && - qstrcmp(yytext,"&") && - qstrcmp(yytext,"^") && - qstrcmp(yytext,"%")) // typically a pointer or reference - { - // not a * or &, or C++/CLI's ^ or % - g_parmType.resize(0);g_parmName.resize(0); - } - g_code->codify(yytext); - } -<MemberCall,MemberCall2,FuncCall>("*"{B}*)?")" { - if (yytext[0]==')') // no a pointer cast - { - //printf("addVariable(%s,%s)\n",g_parmType.data(),g_parmName.data()); - if (g_parmType.isEmpty()) - { - g_parmType=g_parmName; - g_parmName.resize(0); - } - g_theVarContext.addVariable(g_parmType,g_parmName); - } - else - { - g_parmType = g_parmName; - g_parmName.resize(0); - g_theVarContext.addVariable(g_parmType,g_parmName); - } - g_theCallContext.popScope(g_name, g_type); - g_inForEachExpression = FALSE; - //g_theCallContext.setClass(0); // commented out, otherwise a()->b() does not work for b(). - g_code->codify(yytext); - if (--g_bracketCount<=0) - { - if (g_name.isEmpty()) - { - BEGIN( Body ); - } - else - { - BEGIN( CallEnd ); - } - } - } -<CallEnd>[ \t\n]* { codifyLines(yytext); } - /* -<MemberCall2,FuncCall>")"[ \t\n]*[;:] { - */ -<CallEnd>[;:] { - codifyLines(yytext); - g_bracketCount=0; - if (*yytext==';') g_searchingForBody=FALSE; - if (!g_type.isEmpty()) - { - DBG_CTX((stderr,"add variable g_type=%s g_name=%s)\n",g_type.data(),g_name.data())); - g_theVarContext.addVariable(g_type,g_name); - } - g_parmType.resize(0);g_parmName.resize(0); - g_theCallContext.setScope(0); - if (*yytext==';' || g_insideBody) - { - if (!g_insideBody) - { - g_theVarContext.popScope(); - } - g_name.resize(0);g_type.resize(0); - BEGIN( Body ); - } - else - { - g_bracketCount=0; - BEGIN( SkipInits ); - } - } -<CallEnd>("const"|"volatile"|"sealed"|"override")({BN}+("const"|"volatile"|"sealed"|"override"))*/{BN}*(";"|"="|"throw"{BN}*"(") { - startFontClass("keyword"); - codifyLines(yytext); - endFontClass(); - } -<CallEnd,OldStyleArgs>("const"|"volatile"|"sealed"|"override")*({BN}+("const"|"volatile"|"sealed"|"override"))*{BN}*"{" { - if (g_insideBody) - { - g_theVarContext.pushScope(); - } - g_theVarContext.addVariable(g_parmType,g_parmName); - //g_theCallContext.popScope(g_name, g_type); - g_parmType.resize(0);g_parmName.resize(0); - int index = g_name.findRev("::"); - DBG_CTX((stderr,"g_name=%s\n",g_name.data())); - if (index!=-1) - { - QCString scope = g_name.left(index); - if (!g_classScope.isEmpty()) scope.prepend(g_classScope+"::"); - const ClassDef *cd=getResolvedClass(Doxygen::globalScope,g_sourceFileDef,scope); - if (cd) - { - setClassScope(cd->name()); - g_scopeStack.push(SCOPEBLOCK); - DBG_CTX((stderr,"** scope stack push SCOPEBLOCK\n")); - } - else - { - //setClassScope(g_realScope); - g_scopeStack.push(INNERBLOCK); - DBG_CTX((stderr,"** scope stack push INNERBLOCK\n")); - } - } - else - { - DBG_CTX((stderr,"** scope stack push INNERBLOCK\n")); - g_scopeStack.push(INNERBLOCK); - } - yytext[yyleng-1]='\0'; - QCString cv(yytext); - if (!cv.stripWhiteSpace().isEmpty()) - { - startFontClass("keyword"); - codifyLines(yytext); - endFontClass(); - } - else // just whitespace - { - codifyLines(yytext); - } - g_code->codify("{"); - if (g_searchingForBody) - { - g_searchingForBody=FALSE; - g_insideBody=TRUE; - } - if (g_insideBody) g_bodyCurlyCount++; - g_type.resize(0); g_name.resize(0); - BEGIN( Body ); - } -<CallEnd>"try" { // function-try-block - startFontClass("keyword"); - g_code->codify(yytext); - endFontClass(); - g_inFunctionTryBlock=TRUE; - } -<CallEnd>{ID} { - if (g_insideBody || !g_parmType.isEmpty()) - { - REJECT; - } - // could be K&R style definition - addParmType(); - g_parmName=yytext; - generateClassOrGlobalLink(*g_code,yytext,!g_insideBody); - BEGIN(OldStyleArgs); - } -<OldStyleArgs>{ID} { - addParmType(); - g_parmName=yytext; - generateClassOrGlobalLink(*g_code,yytext,!g_insideBody); - } -<OldStyleArgs>[,;] { - g_code->codify(yytext); - g_theVarContext.addVariable(g_parmType,g_parmName); - if (*yytext==';') g_parmType.resize(0); - g_parmName.resize(0); - } -<CallEnd,OldStyleArgs>"#" { - startFontClass("preprocessor"); - g_lastSkipCppContext = Body; - g_code->codify(yytext); - BEGIN( SkipCPP ); - } -<CallEnd>. { - unput(*yytext); - if (!g_insideBody) - { - g_theVarContext.popScope(); - } - g_name.resize(0);g_args.resize(0); - g_parmType.resize(0);g_parmName.resize(0); - BEGIN( Body ); - } -<SkipInits>";" { - g_code->codify(yytext); - g_type.resize(0); g_name.resize(0); - BEGIN( Body ); - } -<SkipInits>"{" { - g_code->codify(yytext); - if (g_searchingForBody) - { - g_searchingForBody=FALSE; - g_insideBody=TRUE; - } - if (g_insideBody) g_bodyCurlyCount++; - if (g_name.find("::")!=-1) - { - DBG_CTX((stderr,"** scope stack push SCOPEBLOCK\n")); - g_scopeStack.push(SCOPEBLOCK); - setClassScope(g_realScope); - } - else - { - DBG_CTX((stderr,"** scope stack push INNERBLOCK\n")); - g_scopeStack.push(INNERBLOCK); - } - g_type.resize(0); g_name.resize(0); - BEGIN( Body ); - } -<SkipInits>{ID} { - generateClassOrGlobalLink(*g_code,yytext); - } -<FuncCall>{ID}/"(" { - generateFunctionLink(*g_code,yytext); - } -<FuncCall>{ID}/("."|"->") { - g_name=yytext; - generateClassOrGlobalLink(*g_code,yytext); - BEGIN( MemberCall2 ); - } -<FuncCall,MemberCall2>("("{B}*("*"{B}*)+{ID}*{B}*")"{B}*)/("."|"->") { - g_code->codify(yytext); - int s=0;while (!isId(yytext[s])) s++; - int e=(int)yyleng-1;while (!isId(yytext[e])) e--; - g_name=((QCString)yytext).mid(s,e-s+1); - BEGIN( MemberCall2 ); - } -<MemberCall2>{ID}/([ \t\n]*"(") { - if (!g_args.isEmpty()) - generateMemberLink(*g_code,g_args,yytext); - else - generateClassOrGlobalLink(*g_code,yytext); - g_args.resize(0); - BEGIN( FuncCall ); - } -<MemberCall2>{ID}/([ \t\n]*("."|"->")) { - //g_code->codify(yytext); - g_name=yytext; - generateClassOrGlobalLink(*g_code,yytext); - BEGIN( MemberCall2 ); - } -<MemberCall2>"->"|"." { - if (yytext[0]=='-') // -> could be overloaded - { - updateCallContextForSmartPointer(); - } - g_code->codify(yytext); - g_memCallContext = YY_START; - BEGIN( MemberCall ); - } -<SkipComment>"/*"("!"?)"*/" { - g_code->codify(yytext); - endFontClass(); - BEGIN( g_lastCContext ) ; - } -<SkipComment>"//"|"/*" { - g_code->codify(yytext); - } -<SkipComment>[^*/\n]+ { - g_code->codify(yytext); - } -<SkipComment>[ \t]*"*/" { - g_code->codify(yytext); - endFontClass(); - if (g_lastCContext==SkipCPP) - { - startFontClass("preprocessor"); - } - BEGIN( g_lastCContext ) ; - } -<SkipCxxComment>[^\r\n]*"\\"[\r]?\n { // line continuation - codifyLines(yytext); - } -<SkipCxxComment>[^\r\n]+ { - g_code->codify(yytext); - } -<SkipCxxComment>\r -<SkipCxxComment>\n { - unput('\n'); - endFontClass(); - BEGIN( g_lastCContext ) ; - } -<SkipCxxComment>. { - g_code->codify(yytext); - } -<RemoveSpecialCComment>"*/"{B}*\n({B}*\n)*({B}*(("//@"[{}])|("/*@"[{}]"*/")){B}*\n)?{B}*"/*"[*!]/[^/*] { - g_yyLineNr+=QCString(yytext).contains('\n'); - } -<RemoveSpecialCComment>"*/"{B}*\n({B}*\n)*({B}*(("//@"[{}])|("/*@"[{}]"*/")){B}*\n)? { - g_yyLineNr+=QCString(yytext).contains('\n'); - nextCodeLine(); - if (g_lastSpecialCContext==SkipCxxComment) - { // force end of C++ comment here - endFontClass(); - BEGIN( g_lastCContext ) ; - } - else - { - BEGIN(g_lastSpecialCContext); - } - } -<RemoveSpecialCComment>"*/" { - BEGIN(g_lastSpecialCContext); - } -<RemoveSpecialCComment>[^*\n]+ -<RemoveSpecialCComment>"//"|"/*" -<RemoveSpecialCComment>\n { g_yyLineNr++; } -<RemoveSpecialCComment>. -<MemberCall>[^a-z_A-Z0-9(\n] { - g_code->codify(yytext); - g_type.resize(0); - g_name.resize(0); - BEGIN(g_memCallContext); - } -<*>\n({B}*"//"[!/][^\n]*\n)+ { // remove special one-line comment - if (YY_START==SkipCPP) REJECT; - if (Config_getBool(STRIP_CODE_COMMENTS)) - { - g_yyLineNr+=((QCString)yytext).contains('\n'); - nextCodeLine(); - } - else - { - startFontClass("comment"); - codifyLines(yytext); - endFontClass(); - } - if (YY_START==SkipCxxComment) - { - endFontClass(); - BEGIN( g_lastCContext ) ; - } - } -<SkipCPP>\n/.*\n { - endFontClass(); - codifyLines(yytext); - BEGIN( g_lastSkipCppContext ) ; - } -<*>\n{B}*"//@"[{}].*\n { // remove one-line group marker - if (Config_getBool(STRIP_CODE_COMMENTS)) - { - g_yyLineNr+=2; - nextCodeLine(); - } - else - { - startFontClass("comment"); - codifyLines(yytext); - endFontClass(); - } - if (YY_START==SkipCxxComment) - { - endFontClass(); - BEGIN( g_lastCContext ) ; - } - } -<*>\n{B}*"/*@"[{}] { // remove one-line group marker - if (Config_getBool(STRIP_CODE_COMMENTS)) - { - if (YY_START != RemoveSpecialCComment) g_lastSpecialCContext = YY_START; - g_yyLineNr++; - BEGIN(RemoveSpecialCComment); - } - else - { - // check is to prevent getting stuck in skipping C++ comments - if (YY_START != SkipComment && YY_START != SkipCxxComment) - { - g_lastCContext = YY_START ; - } - startFontClass("comment"); - codifyLines(yytext); - BEGIN(SkipComment); - } - } -<*>^{B}*"//@"[{}].*\n { // remove one-line group marker - if (Config_getBool(STRIP_CODE_COMMENTS)) - { - g_yyLineNr++; - nextCodeLine(); - } - else - { - startFontClass("comment"); - codifyLines(yytext); - endFontClass(); - } - } -<*>^{B}*"/*@"[{}] { // remove multi-line group marker - if (Config_getBool(STRIP_CODE_COMMENTS)) - { - if (YY_START != RemoveSpecialCComment) g_lastSpecialCContext = YY_START; - BEGIN(RemoveSpecialCComment); - } - else - { - // check is to prevent getting stuck in skipping C++ comments - if (YY_START != SkipComment && YY_START != SkipCxxComment) - { - g_lastCContext = YY_START ; - } - startFontClass("comment"); - g_code->codify(yytext); - BEGIN(SkipComment); - } - } -<*>^{B}*"//"[!/][^\n]*\n { // remove special one-line comment - if (Config_getBool(STRIP_CODE_COMMENTS)) - { - g_yyLineNr++; - //nextCodeLine(); - } - else - { - startFontClass("comment"); - codifyLines(yytext); - endFontClass(); - } - } -<*>"//"[!/][^\n]*\n { // strip special one-line comment - if (YY_START==SkipComment || YY_START==SkipString) REJECT; - if (Config_getBool(STRIP_CODE_COMMENTS)) - { - char c[2]; c[0]='\n'; c[1]=0; - codifyLines(c); - } - else - { - startFontClass("comment"); - codifyLines(yytext); - endFontClass(); - } - } -<*>"/*[tag:"[^\]\n]*"]*/"{B}* { // special pattern /*[tag:filename]*/ to force linking to a tag file - g_forceTagReference=yytext; - int s=g_forceTagReference.find(':'); - int e=g_forceTagReference.findRev(']'); - g_forceTagReference = g_forceTagReference.mid(s+1,e-s-1); - } -<*>\n{B}*"/*"[!*]/[^/*] { - if (Config_getBool(STRIP_CODE_COMMENTS)) - { - if (YY_START != RemoveSpecialCComment) g_lastSpecialCContext = YY_START; - g_yyLineNr++; - BEGIN(RemoveSpecialCComment); - } - else - { - // check is to prevent getting stuck in skipping C++ comments - if (YY_START != SkipComment && YY_START != SkipCxxComment) - { - g_lastCContext = YY_START ; - } - startFontClass("comment"); - codifyLines(yytext); - BEGIN(SkipComment); - } - } -<*>^{B}*"/**"[*]+/[^/] { // special C "banner" comment block at a new line - if (Config_getBool(JAVADOC_BANNER) && Config_getBool(STRIP_CODE_COMMENTS)) - { - if (YY_START != RemoveSpecialCComment) g_lastSpecialCContext = YY_START; - BEGIN(RemoveSpecialCComment); - } - else - { - // check is to prevent getting stuck in skipping C++ comments - if (YY_START != SkipComment && YY_START != SkipCxxComment) - { - g_lastCContext = YY_START ; - } - startFontClass("comment"); - g_code->codify(yytext); - BEGIN(SkipComment); - } - } -<*>^{B}*"/*"[!*]/[^/*] { // special C comment block at a new line - if (Config_getBool(STRIP_CODE_COMMENTS)) - { - if (YY_START != RemoveSpecialCComment) g_lastSpecialCContext = YY_START; - BEGIN(RemoveSpecialCComment); - } - else - { - // check is to prevent getting stuck in skipping C++ comments - if (YY_START != SkipComment && YY_START != SkipCxxComment) - { - g_lastCContext = YY_START ; - } - startFontClass("comment"); - g_code->codify(yytext); - BEGIN(SkipComment); - } - } -<*>"/*"[!*]/[^/*] { // special C comment block half way a line - if (YY_START==SkipString) REJECT; - if (Config_getBool(STRIP_CODE_COMMENTS)) - { - if (YY_START != RemoveSpecialCComment) g_lastSpecialCContext = YY_START; - BEGIN(RemoveSpecialCComment); - } - else - { - // check is to prevent getting stuck in skipping C++ comments - if (YY_START != SkipComment && YY_START != SkipCxxComment) - { - g_lastCContext = YY_START ; - } - startFontClass("comment"); - g_code->codify(yytext); - BEGIN(SkipComment); - } - } -<*>"/*"("!"?)"*/" { - if (YY_START==SkipString) REJECT; - if (!Config_getBool(STRIP_CODE_COMMENTS)) - { - startFontClass("comment"); - g_code->codify(yytext); - endFontClass(); - } - } -<SkipComment>[^\*\n]+ { - g_code->codify(yytext); - } -<*>"/*" { - startFontClass("comment"); - g_code->codify(yytext); - // check is to prevent getting stuck in skipping C++ comments - if (YY_START != SkipComment && YY_START != SkipCxxComment) - { - g_lastCContext = YY_START ; - } - BEGIN( SkipComment ) ; - } -<*>@\" { // C# verbatim string - startFontClass("stringliteral"); - g_code->codify(yytext); - g_lastVerbStringContext=YY_START; - BEGIN(SkipVerbString); - } -<*>"//" { - startFontClass("comment"); - g_code->codify(yytext); - g_lastCContext = YY_START ; - BEGIN( SkipCxxComment ) ; - } -<*>"("|"[" { - g_code->codify(yytext); - g_theCallContext.pushScope(g_name, g_type); - } -<*>")"|"]" { - g_code->codify(yytext); - g_theCallContext.popScope(g_name, g_type); - } -<*>\n { - g_yyColNr++; - codifyLines(yytext); - } -<*>. { - g_yyColNr++; - g_code->codify(yytext); - } - /* -<*>([ \t\n]*"\n"){2,} { // combine multiple blank lines - //QCString sepLine=yytext; - //g_code->codify("\n\n"); - //g_yyLineNr+=sepLine.contains('\n'); - //char sepLine[3]="\n\n"; - codifyLines(yytext); - } - */ - -%% - -/*@ ---------------------------------------------------------------------------- - */ - -static void saveObjCContext() +static void saveObjCContext(yyscan_t yyscanner) { - if (g_currentCtx) + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; + if (yyextra->currentCtx) { - g_currentCtx->format+=QCString().sprintf("$c%d",g_currentCtxId); - if (g_braceCount==0 && YY_START==ObjCCall) + yyextra->currentCtx->format+=QCString().sprintf("$c%d",yyextra->currentCtxId); + if (yyextra->braceCount==0 && YY_START==ObjCCall) { - g_currentCtx->objectTypeOrName=g_currentCtx->format.mid(1); - //printf("new type=%s\n",g_currentCtx->objectTypeOrName.data()); + yyextra->currentCtx->objectTypeOrName=yyextra->currentCtx->format.mid(1); + //printf("new type=%s\n",yyextra->currentCtx->objectTypeOrName.data()); } - g_contextStack.push(g_currentCtx); + yyextra->contextStack.push(yyextra->currentCtx); } else { //printf("Trying to save NULL context!\n"); } ObjCCallCtx *newCtx = new ObjCCallCtx; - newCtx->id = g_currentCtxId; + newCtx->id = yyextra->currentCtxId; newCtx->lexState = YY_START; - newCtx->braceCount = g_braceCount; + newCtx->braceCount = yyextra->braceCount; newCtx->objectType = 0; newCtx->objectVar = 0; newCtx->method = 0; //printf("save state=%d\n",YY_START); - g_contextDict.insert(g_currentCtxId,newCtx); - g_currentCtx = newCtx; - g_braceCount = 0; - g_currentCtxId++; + yyextra->contextDict.insert(yyextra->currentCtxId,newCtx); + yyextra->currentCtx = newCtx; + yyextra->braceCount = 0; + yyextra->currentCtxId++; } -static void restoreObjCContext() +static void restoreObjCContext(yyscan_t yyscanner) { - //printf("restore state=%d->%d\n",YY_START,g_currentCtx->lexState); - BEGIN(g_currentCtx->lexState); - g_braceCount = g_currentCtx->braceCount; - if (!g_contextStack.isEmpty()) + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; + //printf("restore state=%d->%d\n",YY_START,yyextra->currentCtx->lexState); + BEGIN(yyextra->currentCtx->lexState); + yyextra->braceCount = yyextra->currentCtx->braceCount; + if (!yyextra->contextStack.isEmpty()) { - g_currentCtx = g_contextStack.pop(); + yyextra->currentCtx = yyextra->contextStack.pop(); } else { - g_currentCtx = 0; - //printf("Trying to pop context while g_contextStack is empty!\n"); + yyextra->currentCtx = 0; + //printf("Trying to pop context while yyextra->contextStack is empty!\n"); } } -void resetCCodeParserState() +struct CCodeParser::Private +{ + yyscan_t yyscanner; + codeYY_state state; +}; + +CCodeParser::CCodeParser() : p(std::make_unique<CCodeParser::Private>()) +{ + codeYYlex_init_extra(&p->state,&p->yyscanner); +#ifdef FLEX_DEBUG + codeYYset_debug(1,p->yyscanner); +#endif +} + +CCodeParser::~CCodeParser() { - //printf("***initParseCodeContext()\n"); - g_forceTagReference.resize(0); - g_theVarContext.clear(); - g_classScopeLengthStack.setAutoDelete(TRUE); - g_classScopeLengthStack.clear(); - delete g_codeClassSDict; - g_codeClassSDict = new ClassSDict(17); - g_codeClassSDict->setAutoDelete(TRUE); - g_codeClassSDict->clear(); - g_curClassBases.clear(); - g_anchorCount = 0; + struct yyguts_t *yyg = (struct yyguts_t*)p->yyscanner; + yyextra->classScopeLengthStack.clear(); + delete yyextra->codeClassSDict; + yyextra->codeClassSDict=0; + codeYYlex_destroy(p->yyscanner); } -void parseCCode(CodeOutputInterface &od,const char *className,const QCString &s, +void CCodeParser::resetCodeParserState() +{ + struct yyguts_t *yyg = (struct yyguts_t*)p->yyscanner; + //printf("***CodeParser::reset()\n"); + yyextra->forceTagReference.resize(0); + yyextra->theVarContext.clear(); + yyextra->classScopeLengthStack.setAutoDelete(TRUE); + yyextra->classScopeLengthStack.clear(); + delete yyextra->codeClassSDict; + yyextra->codeClassSDict = new ClassSDict(17); + yyextra->codeClassSDict->setAutoDelete(TRUE); + yyextra->codeClassSDict->clear(); + yyextra->curClassBases.clear(); + yyextra->anchorCount = 0; +} + +void CCodeParser::parseCode(CodeOutputInterface &od,const char *className,const QCString &s, SrcLangExt lang,bool exBlock, const char *exName,FileDef *fd, int startLine,int endLine,bool inlineFragment, const MemberDef *memberDef,bool showLineNumbers,const Definition *searchCtx, bool collectXRefs) { + yyscan_t yyscanner = p->yyscanner; + struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; //printf("***parseCode() exBlock=%d exName=%s fd=%p className=%s searchCtx=%s\n", // exBlock,exName,fd,className,searchCtx?searchCtx->name().data():"<none>"); @@ -3782,117 +3915,93 @@ void parseCCode(CodeOutputInterface &od,const char *className,const QCString &s, printlex(yy_flex_debug, TRUE, __FILE__, fd ? fd->fileName().data(): NULL); - if (g_codeClassSDict==0) + if (yyextra->codeClassSDict==0) { - resetCCodeParserState(); + resetCodeParserState(); } - g_code = &od; - g_inputString = s; - g_inputPosition = 0; - g_currentFontClass = 0; - g_needsTermination = FALSE; - g_searchCtx = searchCtx; - g_collectXRefs = collectXRefs; - g_inFunctionTryBlock = FALSE; + yyextra->code = &od; + yyextra->inputString = s; + yyextra->inputPosition = 0; + codeYYrestart(0,yyscanner); + yyextra->currentFontClass = 0; + yyextra->needsTermination = FALSE; + yyextra->searchCtx = searchCtx; + yyextra->collectXRefs = collectXRefs; + yyextra->inFunctionTryBlock = FALSE; if (startLine!=-1) - g_yyLineNr = startLine; + yyextra->yyLineNr = startLine; else - g_yyLineNr = 1; + yyextra->yyLineNr = 1; if (endLine!=-1) - g_inputLines = endLine+1; + yyextra->inputLines = endLine+1; else - g_inputLines = g_yyLineNr + countLines() - 1; - - g_curlyCount = 0; - g_bodyCurlyCount = 0; - g_bracketCount = 0; - g_sharpCount = 0; - g_insideTemplate = FALSE; - g_theCallContext.clear(); - g_scopeStack.clear(); - g_classScope = className; + yyextra->inputLines = yyextra->yyLineNr + countLines(yyscanner) - 1; + + yyextra->curlyCount = 0; + yyextra->bodyCurlyCount = 0; + yyextra->bracketCount = 0; + yyextra->sharpCount = 0; + yyextra->insideTemplate = FALSE; + yyextra->theCallContext.clear(); + yyextra->scopeStack.clear(); + yyextra->classScope = className; //printf("parseCCode %s\n",className); - g_exampleBlock = exBlock; - g_exampleName = exName; - g_sourceFileDef = fd; - g_lineNumbers = fd!=0 && showLineNumbers; + yyextra->exampleBlock = exBlock; + yyextra->exampleName = exName; + yyextra->sourceFileDef = fd; + yyextra->lineNumbers = fd!=0 && showLineNumbers; bool cleanupSourceDef = FALSE; if (fd==0) { // create a dummy filedef for the example - g_sourceFileDef = createFileDef("",(exName?exName:"generated")); + yyextra->sourceFileDef = createFileDef("",(exName?exName:"generated")); cleanupSourceDef = TRUE; } - g_insideObjC = lang==SrcLangExt_ObjC; - g_insideJava = lang==SrcLangExt_Java; - g_insideCS = lang==SrcLangExt_CSharp; - g_insidePHP = lang==SrcLangExt_PHP; - g_insideCpp = lang==SrcLangExt_Cpp; - g_insideSlice = lang==SrcLangExt_Slice; - if (g_sourceFileDef) + yyextra->lang = lang; + yyextra->insideObjC = lang==SrcLangExt_ObjC; + if (yyextra->sourceFileDef) { - setCurrentDoc("l00001"); + setCurrentDoc(yyscanner,"l00001"); } - g_currentDefinition = 0; - g_currentMemberDef = 0; - g_searchingForBody = exBlock; - g_insideBody = FALSE; - g_bracketCount = 0; - if (!g_exampleName.isEmpty()) + yyextra->currentDefinition = 0; + yyextra->currentMemberDef = 0; + yyextra->searchingForBody = exBlock; + yyextra->insideBody = FALSE; + yyextra->bracketCount = 0; + if (!yyextra->exampleName.isEmpty()) { - g_exampleFile = convertNameToFile(g_exampleName+"-example",FALSE,TRUE); - //printf("g_exampleFile=%s\n",g_exampleFile.data()); + yyextra->exampleFile = convertNameToFile(yyextra->exampleName+"-example",FALSE,TRUE); + //printf("yyextra->exampleFile=%s\n",yyextra->exampleFile.data()); } - g_includeCodeFragment = inlineFragment; + yyextra->includeCodeFragment = inlineFragment; //printf("** exBlock=%d exName=%s include=%d\n",exBlock,exName,inlineFragment); - startCodeLine(); - g_type.resize(0); - g_name.resize(0); - g_args.resize(0); - g_parmName.resize(0); - g_parmType.resize(0); - if (memberDef) setParameterList(memberDef); - codeYYrestart( codeYYin ); + startCodeLine(yyscanner); + yyextra->type.resize(0); + yyextra->name.resize(0); + yyextra->args.resize(0); + yyextra->parmName.resize(0); + yyextra->parmType.resize(0); + if (memberDef) setParameterList(yyscanner,memberDef); BEGIN( Body ); - codeYYlex(); - g_lexInit=TRUE; - if (g_needsTermination) + codeYYlex(yyscanner); + yyextra->lexInit=TRUE; + if (yyextra->needsTermination) { - endFontClass(); - DBG_CTX((stderr,"endCodeLine(%d)\n",g_yyLineNr)); - g_code->endCodeLine(); + endFontClass(yyscanner); + DBG_CTX((stderr,"endCodeLine(%d)\n",yyextra->yyLineNr)); + yyextra->code->endCodeLine(); } if (cleanupSourceDef) { // delete the temporary file definition used for this example - delete g_sourceFileDef; - g_sourceFileDef=0; + delete yyextra->sourceFileDef; + yyextra->sourceFileDef=0; } printlex(yy_flex_debug, FALSE, __FILE__, fd ? fd->fileName().data(): NULL); return; } -void codeFreeScanner() -{ -#if defined(YY_FLEX_SUBMINOR_VERSION) - if (g_lexInit) - { - codeYYlex_destroy(); - } -#endif -} - - - -#if !defined(YY_FLEX_SUBMINOR_VERSION) -extern "C" { // some bogus code to keep the compiler happy - void codeYYdummy() { yy_flex_realloc(0,0); } -} -#elif YY_FLEX_MAJOR_VERSION<=2 && YY_FLEX_MINOR_VERSION<=5 && YY_FLEX_SUBMINOR_VERSION<33 -#error "You seem to be using a version of flex newer than 2.5.4. These are currently incompatible with 2.5.4, and do NOT work with doxygen! Please use version 2.5.4 or expect things to be parsed wrongly! A bug report has been submitted (#732132)." -#endif - #include "code.l.h" |