开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 编辑器/阅读器 > 查看源码
parse.c
资源名称：vim53src.zip　[点击查看]
上传用户：gddssl
上传日期：2007-01-06
资源大小：1003k
文件大小：36k
源码类别：

编辑器/阅读器

开发平台：

DOS

parse.c：源码内容
  1. /*****************************************************************************
  2. *   $Id: parse.c,v 6.6 1998/08/20 04:50:36 darren Exp $
  3. *
  4. *   Copyright (c) 1996-1998, Darren Hiebert
  5. *
  6. *   This source code is released for free distribution under the terms of the
  7. *   GNU General Public License.
  8. *
  9. *   This module contains functions for parsing and scanning of a source file.
  10. *****************************************************************************/
  12. /*============================================================================
  13. =   Include files
  14. ============================================================================*/
  15. #ifdef HAVE_CONFIG_H
  16. # include <config.h>
  17. #endif
  18. #include "ctags.h"
  20. /*============================================================================
  21. =   Macros
  22. ============================================================================*/
  23. #define hashIndex(c) ((c) - '_')
  24. #define activeTag(st) ((st)->tag[(int)(st)->buf1])
  25. #define activeName(st) (activeTag(st).name)
  26. #define swapNameBuffers(st) ((st)->buf1 = (boolean)!(st)->buf1)
  28. #define isExternCDecl(st,c) ((c) == STRING_SYMBOL  &&  !(st)->gotName  && 
  29.  (st)->scope == SCOPE_EXTERN)
  31. /*============================================================================
  32. =   Data declarations
  33. ============================================================================*/
  35. /*  Used to specify type of keyword.
  36.  */
  37. typedef enum _keywordId {
  38.     KEYWORD_UNKNOWN,
  39.     KEYWORD_ABSTRACT, KEYWORD_ATTRIBUTE,
  40.     KEYWORD_BOOLEAN, KEYWORD_BYTE,
  41.     KEYWORD_CHAR, KEYWORD_CLASS, KEYWORD_CONST,
  42.     KEYWORD_DOUBLE,
  43.     KEYWORD_ENUM, KEYWORD_EXPLICIT, KEYWORD_EXTERN, KEYWORD_EXTENDS,
  44.     KEYWORD_FINAL, KEYWORD_FLOAT, KEYWORD_FRIEND,
  45.     KEYWORD_IMPLEMENTS, KEYWORD_IMPORT, KEYWORD_INLINE, KEYWORD_INT,
  46.     KEYWORD_INTERFACE,
  47.     KEYWORD_LONG,
  48.     KEYWORD_MUTABLE,
  49.     KEYWORD_NAMESPACE, KEYWORD_NEW, KEYWORD_NATIVE,
  50.     KEYWORD_OPERATOR, KEYWORD_OVERLOAD,
  51.     KEYWORD_PACKAGE, KEYWORD_PRIVATE, KEYWORD_PROTECTED, KEYWORD_PUBLIC,
  52.     KEYWORD_REGISTER,
  53.     KEYWORD_SHORT, KEYWORD_SIGNED, KEYWORD_STATIC, KEYWORD_STRUCT,
  54.     KEYWORD_SYNCHRONIZED,
  55.     KEYWORD_TEMPLATE, KEYWORD_THROW, KEYWORD_THROWS, KEYWORD_TRANSIENT,
  56.     KEYWORD_TYPEDEF, KEYWORD_TYPENAME,
  57.     KEYWORD_UNION, KEYWORD_UNSIGNED, KEYWORD_USING,
  58.     KEYWORD_VIRTUAL, KEYWORD_VOID, KEYWORD_VOLATILE,
  59.     KEYWORD_WCHAR_T
  60. } keywordId;
  62. /*  Used to determine whether keyword is valid for the current language and
  63.  *  what its ID is.
  64.  */
  65. typedef struct _keywordDesc {
  66.     const char *name;
  67.     keywordId id;
  68.     short isValid[LANG_COUNT]; /* indicates languages for which kw is valid */
  69. } keywordDesc;
  71. /*  Used for reporting the type of object parsed by nextToken().
  72.  */
  73. typedef enum _tokenType {
  74.     TOK_NONE, /* none */
  75.     TOK_ARGS, /* a parenthetical pair and its contents */
  76.     TOK_BODY, /* a brace enclosed block */
  77.     TOK_COMMA, /* the comma character */
  78.     TOK_IGNORE, /* a sequence not to be seen by createTags() */
  79.     TOK_ENUM_BODY_END, /* the beginning of a list of enumeration values */
  80.     TOK_EOF, /* end of file */
  81.     TOK_NAME, /* an unknown name */
  82.     TOK_SEMICOLON, /* the semicolon character */
  83.     TOK_SPEC /* a storage class specifier, qualifier, type, etc. */
  84. } tokenType;
  86. /*  Describes the statement currently undergoing analysis.
  87.  */
  88. typedef struct _statementInfo {
  89.     tagScope scope;
  90.     enum _declaration {
  91. DECL_BASE, /* base type (default) */
  92. DECL_CLASS, /* C++ class */
  93. DECL_ENUM, /* enumeration */
  94. DECL_IGNORE, /* non-taggable "declaration" */
  95. DECL_INTERFACE, /* interface */
  96. DECL_NAMESPACE, /* namespace */
  97. DECL_STRUCT, /* structure */
  98. DECL_UNION, /* union */
  99. DECL_NOMANGLE /* C++ name demangling block */
  100.     } declaration; /* describes specifier associated with TOK_SPEC */
  101.     tokenType token; /* the most recent type of token */
  102.     tokenType prev[2]; /* the previous tokens */
  103.     boolean gotName; /* was a name parsed yet? */
  104.     boolean isFuncPtr; /* is 'name' a pointer? */
  105.     boolean inEnumBody; /* currently within enumeration value list? */
  106.     boolean buf1; /* is tag[1] the primary buffer? */
  107.     tagInfo tag[2]; /* information regarding last 2 tag candidates */
  108.     tagInfo class; /* class declaration name info */
  109.     memberInfo member; /* information regarding parent class/struct */
  110. } statementInfo;
  112. /*  Information about an identifier within parentheses.
  113.  */
  114. typedef struct _parenInfo {
  115.     char name[MaxNameLength];
  116.     boolean gotName;
  117.     long location;
  118.     long lineNumber;
  119. } parenInfo;
  121. /*============================================================================
  122. =   Data definitions
  123. ============================================================================*/
  125. enum { HashSize = ('z' - '_' + 1) }; /* '_' through 'z' */
  126. static short KeywordHash[(int)HashSize];
  128. static const keywordDesc KeywordTable[] = {
  129.     /*      C++ */
  130.     /*       ANSI C  |  Java */
  131.     /* keyword keyword ID     |   /   */
  132.     { "__attribute__", KEYWORD_ATTRIBUTE, { 1, 1, 0 } },
  133.     { "abstract", KEYWORD_ABSTRACT, { 0, 0, 1 } },
  134.     { "boolean", KEYWORD_BOOLEAN, { 0, 0, 1 } },
  135.     { "byte", KEYWORD_BYTE, { 0, 0, 1 } },
  136.     { "char", KEYWORD_CHAR, { 1, 1, 1 } },
  137.     { "class", KEYWORD_CLASS, { 0, 1, 1 } },
  138.     { "const", KEYWORD_CONST, { 1, 1, 1 } },
  139.     { "double", KEYWORD_DOUBLE, { 1, 1, 1 } },
  140.     { "enum", KEYWORD_ENUM, { 1, 1, 0 } },
  141.     { "explicit", KEYWORD_EXPLICIT, { 0, 1, 0 } },
  142.     { "extends", KEYWORD_EXTENDS, { 0, 0, 1 } },
  143.     { "extern", KEYWORD_EXTERN, { 1, 1, 0 } },
  144.     { "final", KEYWORD_FINAL, { 0, 0, 1 } },
  145.     { "float", KEYWORD_FLOAT, { 1, 1, 1 } },
  146.     { "friend", KEYWORD_FRIEND, { 0, 1, 0 } },
  147.     { "implements", KEYWORD_IMPLEMENTS, { 0, 0, 1 } },
  148.     { "import", KEYWORD_IMPORT, { 0, 0, 1 } },
  149.     { "inline", KEYWORD_INLINE, { 0, 1, 0 } },
  150.     { "int", KEYWORD_INT, { 1, 1, 1 } },
  151.     { "interface", KEYWORD_INTERFACE, { 0, 0, 1 } },
  152.     { "long", KEYWORD_LONG, { 1, 1, 1 } },
  153.     { "mutable", KEYWORD_MUTABLE, { 0, 1, 0 } },
  154.     { "namespace", KEYWORD_NAMESPACE, { 0, 1, 0 } },
  155.     { "native", KEYWORD_NATIVE, { 0, 0, 1 } },
  156.     { "new", KEYWORD_NEW, { 0, 1, 1 } },
  157.     { "operator", KEYWORD_OPERATOR, { 0, 1, 0 } },
  158.     { "overload", KEYWORD_OVERLOAD, { 0, 1, 0 } },
  159.     { "package", KEYWORD_PACKAGE, { 0, 0, 1 } },
  160.     { "private", KEYWORD_PRIVATE, { 0, 1, 1 } },
  161.     { "protected", KEYWORD_PROTECTED, { 0, 1, 1 } },
  162.     { "public", KEYWORD_PUBLIC, { 0, 1, 1 } },
  163.     { "register", KEYWORD_REGISTER, { 1, 1, 0 } },
  164.     { "short", KEYWORD_SHORT, { 1, 1, 1 } },
  165.     { "signed", KEYWORD_SIGNED, { 1, 1, 0 } },
  166.     { "static", KEYWORD_STATIC, { 1, 1, 1 } },
  167.     { "struct", KEYWORD_STRUCT, { 1, 1, 0 } },
  168.     { "synchronized", KEYWORD_SYNCHRONIZED, { 0, 0, 1 } },
  169.     { "template", KEYWORD_TEMPLATE, { 0, 1, 0 } },
  170.     { "throw", KEYWORD_THROW, { 0, 1, 1 } },
  171.     { "throws", KEYWORD_THROWS, { 0, 0, 1 } },
  172.     { "transient", KEYWORD_TRANSIENT, { 0, 0, 1 } },
  173.     { "typedef", KEYWORD_TYPEDEF, { 1, 1, 0 } },
  174.     { "typename", KEYWORD_TYPENAME, { 0, 1, 0 } },
  175.     { "union", KEYWORD_UNION, { 1, 1, 0 } },
  176.     { "unsigned", KEYWORD_UNSIGNED, { 1, 1, 0 } },
  177.     { "using", KEYWORD_USING, { 0, 1, 0 } },
  178.     { "virtual", KEYWORD_VIRTUAL, { 0, 1, 0 } },
  179.     { "void", KEYWORD_VOID, { 1, 1, 1 } },
  180.     { "volatile", KEYWORD_VOLATILE, { 1, 1, 1 } },
  181.     { "wchar_t", KEYWORD_WCHAR_T, { 1, 1, 0 } }
  182. };
  184. static const size_t KeywordTableSize =
  185. sizeof(KeywordTable)/sizeof(KeywordTable[0]);
  187. /*============================================================================
  188. =   Function prototypes
  189. ============================================================================*/
  190. static void initTag __ARGS((tagInfo *const tag));
  191. static void initMemberInfo __ARGS((memberInfo *const pMember));
  192. static void reinitStatement __ARGS((statementInfo *const st));
  193. static void initStatement __ARGS((statementInfo *const st, const statementInfo *const parent));
  195. /*  Tag generation functions.
  196.  */
  197. static void qualifyBlockTag __ARGS((const statementInfo *const st, const tagInfo *const tag, const tagScope declScope));
  198. static void qualifyEnumeratorTag __ARGS((const statementInfo *const st, const tagInfo *const tag, const tagScope declScope));
  199. static void qualifyFunctionTag __ARGS((statementInfo *const st, const tagInfo *const tag));
  200. static void qualifyVariableTag __ARGS((const statementInfo *const st, const tagInfo *const tag));
  201. static void qualifyFunctionDeclTag __ARGS((const statementInfo *const st, const tagInfo *const tag));
  203. /*  Parsing functions.
  204.  */
  205. static int skipToNonWhite __ARGS((void));
  206. static void skipToFormattedBraceMatch __ARGS((void));
  207. static boolean skipToMatch __ARGS((const char *const pair));
  208. static void readIdentifier __ARGS((const int firstChar, char *const name));
  209. static void readOperator __ARGS((const int firstChar, char *const name));
  210. static keywordId analyzeKeyword __ARGS((const char *const name));
  211. static void processKeyword __ARGS((statementInfo *const st, keywordId keyword));
  212. static int skipPostArgumentStuff __ARGS((int c, statementInfo *const st, const boolean emptyArgList));
  213. static boolean analyzePostParens __ARGS((statementInfo *const st, const parenInfo *const paren, const boolean emptyArgList));
  214. static void initParenInfo __ARGS((parenInfo *const paren));
  215. static boolean saveParenInfo __ARGS((parenInfo *const paren, int c));
  216. static boolean doubleParens __ARGS((statementInfo *const st));
  217. static boolean analyzeParens __ARGS((statementInfo *const st));
  218. static void analyzeIdentifier __ARGS((statementInfo *const st));
  219. static boolean beginBlock __ARGS((statementInfo *const st, const unsigned int nesting));
  220. static boolean endBlock __ARGS((statementInfo *const st, const unsigned int nesting));
  221. static void processColon __ARGS((statementInfo *const st));
  222. static int skipInitializer __ARGS((const boolean inEnumBody));
  223. static boolean processInitializer __ARGS((statementInfo *const st));
  224. static boolean processArray __ARGS((statementInfo *const st));
  225. static boolean processTemplate __ARGS((statementInfo *const st));
  226. static void processIdentifier __ARGS((statementInfo *const st, const int c));
  227. static boolean nextToken __ARGS((statementInfo *const st, const unsigned int nesting));
  229. /*============================================================================
  230. =   Function definitions
  231. ============================================================================*/
  233. static void initTag( tag )
  234.     tagInfo *const tag;
  235. {
  236.     tag->location = 0;
  237.     tag->lineNumber = 0;
  238.     tag->name[0] = '';
  239.     DebugStatement( clearString(tag->name, MaxNameLength); )
  240. }
  242. static void initMemberInfo( pMember )
  243.     memberInfo *const pMember;
  244. {
  245.     pMember->type = MEMBER_NONE;
  246.     pMember->visibility = VIS_UNDEFINED;
  247.     pMember->parent[0] = '';
  248.     DebugStatement( clearString(pMember->parent, MaxNameLength); )
  249. }
  251. static void reinitStatement( st )
  252.     statementInfo *const st;
  253. {
  254.     int i;
  256.     st->scope = SCOPE_GLOBAL;
  257.     st->declaration = DECL_BASE;
  258.     st->token = TOK_NONE;
  259.     st->prev[0] = TOK_NONE;
  260.     st->prev[1] = TOK_NONE;
  261.     st->gotName = FALSE;
  262.     st->isFuncPtr = FALSE;
  263.     st->buf1 = FALSE;
  265.     for (i = 0  ;  i < 2  ;  ++i)
  266. initTag(&st->tag[i]);
  268.     initTag(&st->class);
  270.     if (st->member.type != MEMBER_NONE  &&  ! st->member.persistent)
  271. initMemberInfo(&st->member);
  272. }
  274. static void initStatement( st, parent )
  275.     statementInfo *const st;
  276.     const statementInfo *const parent;
  277. {
  278.     /*  Set the member information. If there is a parent statement, inherit
  279.      *  the parent member information from it.
  280.      */
  281.     if (parent == NULL)
  282.     {
  283. initMemberInfo(&st->member);
  284. st->inEnumBody = FALSE;
  285.     }
  286.     else
  287.     {
  288. st->inEnumBody = (boolean)(parent->declaration == DECL_ENUM);
  289. st->member.visibility = VIS_UNDEFINED;
  290. switch (parent->declaration)
  291. {
  292.     case DECL_ENUM: st->member.type = MEMBER_ENUM; break;
  293.     case DECL_CLASS: st->member.type = MEMBER_CLASS;
  294. st->member.visibility = VIS_PRIVATE; break;
  295.     case DECL_INTERFACE:st->member.type = MEMBER_INTERFACE; break;
  296.     case DECL_NAMESPACE:st->member.type = MEMBER_NAMESPACE; break;
  297.     case DECL_STRUCT: st->member.type = MEMBER_STRUCT;
  298. st->member.visibility = VIS_PUBLIC; break;
  299.     case DECL_UNION: st->member.type = MEMBER_UNION; break;
  300.     default: st->member.type = MEMBER_NONE; break;
  301. }
  302. DebugStatement( clearString(st->member.parent, MaxNameLength); )
  303. if (st->member.type != MEMBER_NONE)
  304. {
  305.     st->member.persistent = TRUE;
  306.     if (parent->declaration == DECL_CLASS)
  307. strcpy(st->member.parent, parent->class.name);
  308.     else
  309. strcpy(st->member.parent,
  310.        (parent->prev[0] == TOK_NAME) ? activeName(parent) : "");
  311. }
  312.     }
  313.     reinitStatement(st);
  314. }
  316. /*----------------------------------------------------------------------------
  317. *- Tag generation functions
  318. ----------------------------------------------------------------------------*/
  320. static void qualifyBlockTag( st, tag, declScope )
  321.     const statementInfo *const st;
  322.     const tagInfo *const tag;
  323.     const tagScope declScope;
  324. {
  325.     if (st->prev[0] == TOK_NAME)
  326.     {
  327. boolean ok = TRUE;
  328. tagType type = TAG_NUMTYPES; /* assignment to avoid warning */
  330. switch (st->declaration)
  331. {
  332.     case DECL_CLASS: type = TAG_CLASS; break;
  333.     case DECL_ENUM: type = TAG_ENUM; break;
  334.     case DECL_INTERFACE:type = TAG_INTERFACE; break;
  335.     case DECL_NAMESPACE:type = TAG_NAMESPACE; break;
  336.     case DECL_STRUCT: type = TAG_STRUCT; break;
  337.     case DECL_UNION: type = TAG_UNION; break;
  338.     default: ok = FALSE; break;
  339. }
  340. if (ok)
  341.     makeTag(tag, &st->member, declScope, type);
  342.     }
  343. }
  345. static void qualifyEnumeratorTag( st, tag, declScope )
  346.     const statementInfo *const st;
  347.     const tagInfo *const tag;
  348.     const tagScope declScope;
  349. {
  350.     if (st->token == TOK_NAME)
  351. makeTag(tag, &st->member, declScope, TAG_ENUMERATOR);
  352. }
  354. static void qualifyFunctionTag( st, tag )
  355.     statementInfo *const st;
  356.     const tagInfo *const tag;
  357. {
  358.     if (st->scope == SCOPE_EXTERN) /* allowed for func. def. */
  359. st->scope = SCOPE_GLOBAL;
  360.     makeTag(tag, &st->member, st->scope, TAG_FUNCTION);
  361. }
  363. static void qualifyVariableTag( st, tag )
  364.     const statementInfo *const st;
  365.     const tagInfo *const tag;
  366. {
  367.     /* We have to watch that we do not interpret a declaration of the
  368.      * form "struct tag;" as a variable definition. In such a case, the
  369.      * declaration will be either class, enum, struct or union, and prev[1]
  370.      * will be empty.
  371.      */
  372.     if (st->declaration == DECL_IGNORE)
  373. ;
  374.     else if (st->declaration == DECL_BASE  ||  st->prev[1] != TOK_SPEC)
  375.     {
  376. if (st->member.type == MEMBER_NONE)
  377. {
  378.     if (st->scope == SCOPE_EXTERN)
  379. makeTag(tag, &st->member, st->scope, TAG_EXTERN_VAR);
  380.     else
  381. makeTag(tag, &st->member, st->scope, TAG_VARIABLE);
  382. }
  383. else
  384. {
  385.     if (st->scope == SCOPE_GLOBAL)
  386. makeTag(tag, &st->member, st->scope, TAG_MEMBER);
  387.     else if (st->scope == SCOPE_STATIC)
  388. makeTag(tag, &st->member, SCOPE_EXTERN, TAG_MEMBER);
  389. }
  390.     }
  391. }
  393. static void qualifyFunctionDeclTag( st, tag )
  394.     const statementInfo *const st;
  395.     const tagInfo *const tag;
  396. {
  397.     if (! File.isHeader)
  398. makeTag(tag, &st->member, SCOPE_STATIC, TAG_FUNCDECL);
  399.     else if (st->scope == SCOPE_GLOBAL  ||  st->scope == SCOPE_EXTERN)
  400. makeTag(tag, &st->member, SCOPE_GLOBAL, TAG_FUNCDECL);
  401. }
  403. /*----------------------------------------------------------------------------
  404. *- Parsing functions
  405. ----------------------------------------------------------------------------*/
  407. /*  Skip to the next non-white character.
  408.  */
  409. static int skipToNonWhite()
  410. {
  411.     int c;
  413.     do
  414.     {
  415. c = cppGetc();
  416.     } while (c != EOF  &&  isspace(c));
  418.     return c;
  419. }
  421. #if 0
  422. /*  Skip to the next occurance of the specified character.
  423.  */
  424. static int skipToCharacter( findchar )
  425.     const int findchar;
  426. {
  427.     int c;
  429.     do
  430. c = cppGetc();
  431.     while (c != EOF  &&  c != findchar);
  433.     return c;
  434. }
  435. #endif
  437. /*  Skips to the next brace in column 1. This is intended for cases where
  438.  *  preprocessor constructs result in unbalanced braces.
  439.  */
  440. static void skipToFormattedBraceMatch()
  441. {
  442.     int c, next;
  444.     c = cppGetc();
  445.     next = cppGetc();
  446.     while (c != EOF  &&  (c != 'n'  ||  next != '}'))
  447.     {
  448. c = next;
  449. next = cppGetc();
  450.     }
  451. }
  453. /*  Skip to the matching character indicated by the pair string. If skipping
  454.  *  to a matching brace and any brace is found within a different level of a
  455.  *  #if conditional statement while brace formatting is in effect, we skip to
  456.  *  the brace matched by its formatting. It is assumed that we have already
  457.  *  read the character which starts the group (i.e. the first character of
  458.  *  "pair").
  459.  */
  460. static boolean skipToMatch( pair )
  461.     const char *const pair;
  462. {
  463.     const int begin = pair[0], end = pair[1];
  464.     const unsigned int initialLevel = Cpp.directive.nestLevel;
  465.     const boolean braceFormatting = (boolean)(Option.braceFormat &&
  466.       strcmp("{}", pair) == 0);
  467.     boolean ok = TRUE;
  468.     int matchLevel = 1;
  469.     int c = '';
  471.     while (matchLevel > 0  &&  (c = cppGetc()) != EOF)
  472.     {
  473. if (c == begin)
  474. {
  475.     ++matchLevel;
  476.     if (braceFormatting  &&  Cpp.directive.nestLevel != initialLevel)
  477.     {
  478. skipToFormattedBraceMatch();
  479. break;
  480.     }
  481. }
  482. else if (c == end)
  483. {
  484.     --matchLevel;
  485.     if (braceFormatting  &&  Cpp.directive.nestLevel != initialLevel)
  486.     {
  487. skipToFormattedBraceMatch();
  488. break;
  489.     }
  490. }
  491.     }
  492.     if (c == EOF)
  493. ok = FALSE;
  495.     return ok;
  496. }
  498. /*  Read a C identifier beginning with "firstChar" and places it into "name".
  499.  */
  500. static void readIdentifier( firstChar, name )
  501.     const int firstChar;
  502.     char *const name;
  503. {
  504.     int c, i;
  506.     name[0] = firstChar;
  507.     for (i = 1, c = cppGetc() ;
  508.  i < (int)MaxNameLength - 1  &&  isident(c) ;
  509.  i++, c = cppGetc())
  510.     {
  511. name[i] = c;
  512.     }
  513.     name[i] = ''; /* null terminate name */
  515.     cppUngetc(c); /* unget non-identifier character */
  516. }
  518. /*  Read a C++ operator and appends to "name" (which should contain "operator").
  519.  */
  520. static void readOperator( firstChar, name )
  521.     const int firstChar;
  522.     char *const name;
  523. {
  524.     int c, i;
  526.     for (c = firstChar, i = strlen(name) ;
  527.  i < (int)MaxNameLength - 1  &&  ! isspace(c)  &&  c != '(' ;
  528.  i++, c = cppGetc())
  529.     {
  530. name[i] = c;
  531.     }
  532.     if (i > 0)
  533. name[i] = ''; /* null terminate operator */
  535.     cppUngetc(c); /* unget non-operator character */
  536. }
  538. /*  Analyzes the identifier contained in a statement described by the
  539.  *  statement structure and adjusts the structure according the significance
  540.  *  of the identifier.
  541.  */
  542. static keywordId analyzeKeyword( name )
  543.     const char *const name;
  544. {
  545.     keywordId id = KEYWORD_UNKNOWN;
  547.     if (name[0] == '_'  ||  islower(name[0]))
  548.     {
  549. const short hash = KeywordHash[hashIndex(name[0])];
  551. if (hash >= 0)
  552. {
  553.     unsigned int i;
  555.     for (i = hash  ;  i < KeywordTableSize  ;  ++i)
  556.     {
  557. const keywordDesc *pKw = &KeywordTable[i];
  559. if (pKw->name[0] != name[0])
  560.     break;
  562. if (pKw->isValid[File.language] && strcmp(pKw->name, name) == 0)
  563. {
  564.     id = pKw->id;
  565.     break;
  566. }
  567.     }
  568. }
  569.     }
  570.     return id;
  571. }
  573. static void processKeyword( st, keyword )
  574.     statementInfo *const st;
  575.     keywordId keyword;
  576. {
  577.     st->token = TOK_SPEC; /* default unless otherwise */
  579.     switch (keyword) /* is it a reserved word? */
  580.     {
  581. default: st->token = TOK_IGNORE; break;
  583. case KEYWORD_CHAR: st->declaration = DECL_BASE; break;
  584. case KEYWORD_CLASS: st->declaration = DECL_CLASS; break;
  585. case KEYWORD_DOUBLE: st->declaration = DECL_BASE; break;
  586. case KEYWORD_ENUM: st->declaration = DECL_ENUM; break;
  587. case KEYWORD_EXTERN: st->scope = SCOPE_EXTERN; break;
  588. case KEYWORD_FLOAT: st->declaration = DECL_BASE; break;
  589. case KEYWORD_FRIEND: st->scope = SCOPE_FRIEND; break;
  590. case KEYWORD_IMPORT: st->declaration = DECL_IGNORE; break;
  591. case KEYWORD_INT: st->declaration = DECL_BASE; break;
  592. case KEYWORD_INTERFACE: st->declaration = DECL_INTERFACE; break;
  593. case KEYWORD_LONG: st->declaration = DECL_BASE; break;
  594. case KEYWORD_NAMESPACE: st->declaration = DECL_NAMESPACE; break;
  595. case KEYWORD_PACKAGE: st->declaration = DECL_IGNORE; break;
  596. case KEYWORD_PRIVATE: st->member.visibility = VIS_PRIVATE; break;
  597. case KEYWORD_PROTECTED: st->member.visibility = VIS_PROTECTED; break;
  598. case KEYWORD_PUBLIC: st->member.visibility = VIS_PUBLIC; break;
  599. case KEYWORD_SHORT: st->declaration = DECL_BASE; break;
  600. case KEYWORD_SIGNED: st->declaration = DECL_BASE; break;
  601. case KEYWORD_STRUCT: st->declaration = DECL_STRUCT; break;
  602. case KEYWORD_TYPEDEF: st->scope = SCOPE_TYPEDEF; break;
  603. case KEYWORD_UNION: st->declaration = DECL_UNION; break;
  604. case KEYWORD_UNSIGNED: st->declaration = DECL_BASE; break;
  605. case KEYWORD_VOID: st->declaration = DECL_BASE; break;
  607. case KEYWORD_ATTRIBUTE:
  608. {
  609.     const int c = skipToNonWhite();
  611.     if (c == '(')
  612. skipToMatch("()");
  613.     else
  614. cppUngetc(c);
  615.     st->token = TOK_IGNORE;
  616.     break;
  617. }
  619. case KEYWORD_EXTENDS:
  620. case KEYWORD_IMPLEMENTS:
  621. case KEYWORD_THROWS:
  622. {
  623.     char *const name = activeName(st);
  624.     int c = skipToNonWhite();
  626.     /*  Read and discard interface or class type-list (ident[, ident]).
  627.      */
  628.     while (isident1(c))
  629.     {
  630. readIdentifier(c, name);
  631. c = skipToNonWhite();
  632. if (c == '.'  ||  c == ',')
  633.     c = skipToNonWhite();
  634.     }
  635.     cppUngetc(c);
  636.     st->token = TOK_IGNORE;
  637.     break;
  638. }
  640. case KEYWORD_STATIC:
  641.     if (File.language != LANG_JAVA)
  642. st->scope = SCOPE_STATIC;
  643.     break;
  645. case KEYWORD_OPERATOR:
  646. {
  647.     char *const name = activeName(st);
  648.     const int c = skipToNonWhite();
  650.     if (isident1(c))
  651. readIdentifier(c, name);
  652.     else
  653. readOperator(c, name);
  654. } /* fall through to unknown keyword case */
  655. case KEYWORD_UNKNOWN:
  656. {
  657.     tagInfo *const tag = &activeTag(st);
  659.     st->token = TOK_NAME;
  660.     st->gotName = TRUE;
  662.     tag->location   = File.seek;
  663.     tag->lineNumber = File.lineNumber;
  665.     if (st->declaration == DECL_CLASS  &&  st->class.name[0] == '')
  666.     {
  667. strcpy(st->class.name, tag->name);
  668. st->class.location   = tag->location;
  669. st->class.lineNumber = tag->lineNumber;
  670.     }
  671.     break;
  672. }
  673.     }
  674. }
  676. /*  Skips over characters following the parameter list. This might be non-ANSI
  677.  *  style function declarations, a C++ exception specification, or another C++
  678.  *  construct that I don't yet understand (e.g. "void Class::foo(int a):
  679.  *  attr(v1), attr(v2)").
  680.  */
  681. static int skipPostArgumentStuff( c, st, emptyArgList )
  682.     int c;
  683.     statementInfo *const st;
  684.     const boolean emptyArgList;
  685. {
  686.     boolean end = FALSE, firstSemicolon = TRUE;
  687.     boolean skipCPlusStuff = (boolean)(c == ':');
  688.     unsigned int tokenCount = 0;
  690.     while (c != EOF  &&  ! end)
  691.     {
  692. if (skipCPlusStuff)
  693. {
  694.     if (c == '{'  ||  c == ';')
  695. break;
  696. }
  697. else if (isident1(c))
  698. {
  699.     char name[MaxNameLength];
  700.     keywordId keyword;
  702.     readIdentifier(c, name);
  703.     ++tokenCount;
  704.     keyword = analyzeKeyword(name);
  705.     switch (keyword)
  706.     {
  707.     /*  These words are explicitly allowed following the closing
  708.      *  parenthesis in C++.
  709.      */
  710.     case KEYWORD_CONST:
  711. break;
  713.     case KEYWORD_THROW:
  714. skipCPlusStuff = TRUE;
  715. break;
  717.     /*  These words are never allowed within parameter declarations.
  718.      */
  719.     case KEYWORD_CLASS:
  720.     case KEYWORD_EXTERN:
  721.     case KEYWORD_STATIC:
  722.     case KEYWORD_TYPEDEF:
  723. DebugStatement( if (debug(DEBUG_PARSE)) printf("<ES>"); )
  724. reinitStatement(st);
  725. processKeyword(st, keyword);
  726. c = skipToNonWhite();
  727. end = TRUE;
  728. continue; /* skip read of next character */
  730.     case KEYWORD_ATTRIBUTE:
  731. {
  732.     c = skipToNonWhite();
  733.     if (c == '('  &&  ! skipToMatch("()"))
  734. c = EOF;
  735. }
  736. break;
  738.     default:
  739. /*  If we encounter any other identifier immediately following
  740.  *  an empty parameter list, this is almost certainly one of
  741.  *  those Microsoft macro "thingies" that the automatic source
  742.  *  code generation sticks in. Terminate the current statement.
  743.  */
  744. if (emptyArgList)
  745. {
  746.     DebugStatement( if (debug(DEBUG_PARSE)) printf("<ES>"); )
  747.     reinitStatement(st);
  748.     processKeyword(st, keyword);
  749.     c = skipToNonWhite();
  750.     end = TRUE;
  751.     continue; /* skip read of next character */
  752. }
  753. break;
  754.     }
  755. }
  756. else switch (c)
  757. {
  758. default:    break; /* ignore */
  760. case ';':
  761.     /*  A lone word is most likely a preprocessor qualifier.
  762.      */
  763.     if (firstSemicolon  &&  tokenCount == 1)
  764.     {
  765. end = TRUE;
  766. continue;
  767.     }
  768.     else
  769.     {
  770. tokenCount = 0;
  771. firstSemicolon = FALSE;
  772. break;
  773.     }
  775. case '(':
  776.     ++tokenCount;
  777.     if (! skipToMatch("()"))
  778. c = EOF;
  779.     break;
  781. case '[':   if (! skipToMatch("[]"))  c = EOF; break;
  782. case '{':
  783. case '}':   end = TRUE;
  784.     continue; /* skip read of next character */
  785. }
  786. if (c != EOF)
  787.     c = cppGetc();
  788.     }
  789.     return c;
  790. }
  792. static boolean analyzePostParens( st, paren, emptyArgList )
  793.     statementInfo *const st;
  794.     const parenInfo *const paren;
  795.     const boolean emptyArgList;
  796. {
  797.     boolean ok = TRUE;
  798.     int c;
  800.     /* At this point we should be at the character following the
  801.      * closing parenthesis.
  802.      */
  803.     c = skipToNonWhite();
  804.     if (st->gotName)
  805.     {
  806. if (strchr("{;,", c) != NULL)
  807. {
  808.     st->token = TOK_ARGS; /* parameter list to a func. */
  809.     st->declaration = DECL_BASE; /* clear any other decl. */
  810. }
  811. else if (isident1(c)  ||  c == ':')
  812. {
  813.     st->token = TOK_ARGS; /* parameter list to a func. */
  814.     st->declaration = DECL_BASE; /* clear any other decl. */
  815.     if (File.language != LANG_JAVA)
  816. c = skipPostArgumentStuff(c, st, emptyArgList);
  817. }
  818. else
  819.     st->token = TOK_IGNORE;
  820.     }
  821.     /* The name inside the parentheses must have been a function or
  822.      * variable name.
  823.      */
  824.     else if (paren->gotName)
  825.     {
  826. tagInfo *const tag = &activeTag(st);
  828. st->gotName = TRUE;
  829. st->token = TOK_NAME;
  830. tag->location = paren->location;
  831. tag->lineNumber = paren->lineNumber;
  832. strcpy(tag->name, paren->name);
  833.     }
  834.     else
  835. st->token = TOK_IGNORE;
  836.     if (c == EOF)
  837. ok = FALSE;
  838.     else
  839. cppUngetc(c);
  841.     return ok;
  842. }
  844. static void initParenInfo( paren )
  845.     parenInfo *const paren;
  846. {
  847.     DebugStatement( clearString(paren->name, MaxNameLength); )
  848.     paren->gotName = FALSE;
  849.     paren->location = 0;
  850.     paren->lineNumber = 0;
  851. }
  853. static boolean saveParenInfo( paren, c )
  854.     parenInfo *const paren;
  855.     int c;
  856. {
  857.     boolean ok = TRUE;
  859.     readIdentifier(c, paren->name);
  860.     c = skipToNonWhite();
  861.     if (c == ')') /* saved if only identifier in parentheses */
  862.     {
  863. paren->gotName    = TRUE;
  864. paren->location   = File.seek;
  865. paren->lineNumber = File.lineNumber;
  866.     }
  867.     else
  868.     {
  869. if (c == '(')
  870.     cppUngetc(c);
  871. ok = skipToMatch("()");
  872.     }
  873.     return ok;
  874. }
  876. static boolean doubleParens( st )
  877.     statementInfo *const st;
  878. {
  879.     /* A double parenthesis almost certainly means one of those conditional
  880.      * prototype macro thingies (e.g. __ARGS((void)) ). If found, we will use
  881.      * the previous name, if it is not empty.
  882.      */
  883.     if (st->gotName  &&  *st->tag[!st->buf1].name != '')
  884. swapNameBuffers(st);
  886.     cppUngetc('('); /* put back for skipToMatch() */
  887.     return skipToMatch("()");
  888. }
  890. /*  Analyzes the context and contents of parentheses.
  891.  */
  892. static boolean analyzeParens( st )
  893.     statementInfo *const st;
  894. {
  895.     boolean ok = TRUE;
  896.     int c;
  898.     c = skipToNonWhite();
  899.     if (c == '*') /* this is a function pointer */
  900.     {
  901. st->gotName = FALSE; /* invalidate previous name */
  902. st->isFuncPtr = TRUE;
  903. st->token = TOK_IGNORE;
  904.     }
  905.     if (! st->gotName)
  906.     {
  907. st->token = TOK_IGNORE;
  908. cppUngetc(c);
  909.     }
  910.     else
  911.     {
  912. boolean terminate = FALSE, emptyArgList = FALSE;
  913. parenInfo paren;
  915. initParenInfo(&paren);
  916. if (isident1(c))
  917.     ok = saveParenInfo(&paren, c);
  918. else if (c == '(')
  919.     ok = doubleParens(st);
  920. else if (c == ')') /* empty parentheses... */
  921.     emptyArgList = TRUE;
  922. else
  923. {
  924.     /* This is an invalid character to be inside a paren in this
  925.      * context. This must be a macro call. After we read to the
  926.      * end of the parenthesis seqence, force a termination of the
  927.      * current statement,
  928.      */
  929.     st->token = TOK_NONE;
  930.     st->gotName = FALSE;
  931.     terminate = TRUE;
  932.     ok = skipToMatch("()");
  933. }
  934. if (ok  &&  ! terminate)
  935.     ok = analyzePostParens(st, &paren, emptyArgList);
  936.     }
  937.     return ok;
  938. }
  940. /*  Analyzes the identifier contained in a statement described by the
  941.  *  statement structure and adjusts the structure according the significance
  942.  *  of the identifier.
  943.  */
  944. static void analyzeIdentifier( st )
  945.     statementInfo *const st;
  946. {
  947.     tagInfo *const tag = &activeTag(st);
  948.     char *const name = tag->name;
  950.     if (isIgnoreToken(name))
  951. st->token = TOK_IGNORE;
  952.     else
  953. processKeyword(st, analyzeKeyword(name));
  955.     if (st->token == TOK_IGNORE)
  956. name[0] = '';
  957. }
  959. static void processIdentifier( st, c )
  960.     statementInfo *const st;
  961.     const int c;
  962. {
  963.     if (st->gotName)
  964. swapNameBuffers(st);
  965.     readIdentifier(c, activeName(st));
  966.     analyzeIdentifier(st);
  967.     if (st->gotName  &&  st->token == TOK_IGNORE)
  968. swapNameBuffers(st);
  969. }
  971. static void processColon( st )
  972.     statementInfo *const st;
  973. {
  974.     if (st->declaration != DECL_CLASS)
  975.     {
  976. const int c = skipToNonWhite();
  978. if (c == ':') /* this is a method or static member definition */
  979. {
  980.     st->member.type = MEMBER_CLASS;
  981.     strcpy(st->member.parent, activeName(st));
  982.     st->member.persistent = FALSE;
  983. }
  984. else
  985. {
  986.     cppUngetc(c);
  987.     st->token = TOK_IGNORE;
  988. }
  989.     }
  990. }
  992. /*  Skips over any initializing value which may follow a '=' character in a
  993.  *  variable definition.
  994.  */
  995. static int skipInitializer( enumInitializer )
  996.     const boolean enumInitializer;
  997. {
  998.     boolean done = FALSE;
  999.     int c;
  1001.     do
  1002.     {
  1003. c = cppGetc();
  1005. if (c != EOF) switch (c)
  1006. {
  1007.     case ',':
  1008.     case ';':   done = TRUE; break;
  1010.     case '[':   if (! skipToMatch("[]"))
  1011.     c = EOF;
  1012. break;
  1013.     case '(':   if (! skipToMatch("()"))
  1014.     c = EOF;
  1015. break;
  1016.     case '{':   if (! skipToMatch("{}"))
  1017.     c = EOF;
  1018. break;
  1019.     case '}':   if (enumInitializer)
  1020. {
  1021.     cppUngetc(c);
  1022.     done = TRUE;
  1023. }
  1024. else if (! Option.braceFormat)
  1025.     c = EOF;
  1026. break;
  1028.     default:    break;
  1029. }
  1030.     } while (! done  &&  c != EOF);
  1032.     return c;
  1033. }
  1035. static boolean processInitializer( st )
  1036.     statementInfo *const st;
  1037. {
  1038.     boolean ok = TRUE;
  1039.     const int c = skipInitializer(st->inEnumBody);
  1041.     if (c == EOF)
  1042. ok = FALSE;
  1043.     else if (c == ';')
  1044. st->token = TOK_SEMICOLON;
  1045.     else if (c == ',')
  1046. st->token = TOK_COMMA;
  1047.     else if ('}'  &&  st->inEnumBody)
  1048. st->token = TOK_COMMA;
  1050.     if (st->scope == SCOPE_EXTERN)
  1051. st->scope = SCOPE_GLOBAL;
  1053.     return ok;
  1054. }
  1056. static boolean processArray( st )
  1057.     statementInfo *const st;
  1058. {
  1059.     st->token = TOK_IGNORE;
  1060.     return skipToMatch("[]");
  1061. }
  1063. static boolean processTemplate( st )
  1064.     statementInfo *const st;
  1065. {
  1066.     st->token = TOK_IGNORE;
  1067.     return skipToMatch("<>");
  1068. }
  1070. static boolean beginBlock( st, nesting )
  1071.     statementInfo *const st;
  1072.     const unsigned int nesting;
  1073. {
  1074.     const tagScope declScope = (File.isHeader || File.language == LANG_JAVA) ?
  1075. SCOPE_GLOBAL : SCOPE_STATIC;
  1076.     tagInfo *const tag = &activeTag(st);
  1077.     boolean ok;
  1079.     switch (st->declaration)
  1080.     {
  1081. case DECL_CLASS:
  1082.     qualifyBlockTag(st, &st->class, declScope);
  1083.     ok = createTags(nesting + 1, st);
  1084.     break;
  1086. case DECL_ENUM:
  1087. case DECL_INTERFACE:
  1088. case DECL_NAMESPACE:
  1089. case DECL_STRUCT:
  1090. case DECL_UNION:
  1091.     qualifyBlockTag(st, tag, declScope);
  1092.     ok = createTags(nesting + 1, st);
  1093.     break;
  1095. case DECL_NOMANGLE:
  1096.     ok = createTags(nesting + 1, st);
  1097.     break;
  1099. default:
  1100.     ok = skipToMatch("{}");
  1101.     }
  1102.     st->token = TOK_BODY;
  1104.     return ok;
  1105. }
  1107. static boolean endBlock( st, nesting )
  1108.     statementInfo *const st;
  1109.     const unsigned int nesting;
  1110. {
  1111.     boolean ok = TRUE;
  1113.     if (nesting > 0)
  1114. st->token = TOK_EOF; /* fake out */
  1115.     else
  1116.     {
  1117. st->token = TOK_IGNORE;
  1118. ok = FALSE;
  1119.     }
  1120.     return ok;
  1121. }
  1123. /*  Reads characters from the pre-processor and assembles tokens, setting
  1124.  *  the current statement state.
  1125.  */
  1126. static boolean nextToken( st, nesting )
  1127.     statementInfo *const st;
  1128.     const unsigned int nesting;
  1129. {
  1130.     int c;
  1131.     boolean ok = TRUE;
  1133.     do
  1134.     {
  1135. c = cppGetc();
  1137. switch (c)
  1138. {
  1139.     case EOF:   st->token = TOK_EOF; break;
  1140.     case '(':   ok = analyzeParens(st); break;
  1141.     case '*':   st->gotName = FALSE; break;
  1142.     case ',':   st->token = TOK_COMMA; break;
  1143.     case ':':   processColon(st); break;
  1144.     case ';':   st->token = TOK_SEMICOLON; break;
  1145.     case '=':   ok = processInitializer(st); break;
  1146.     case '[':   ok = processArray(st); break;
  1147.     case '{':   ok = beginBlock(st, nesting); break;
  1148.     case '}':   ok = endBlock(st, nesting); break;
  1149.     case '<':   ok = processTemplate(st); break;
  1151.     default:
  1152. if (isident1(c))
  1153.     processIdentifier(st, c);
  1154. else if (isExternCDecl(st, c))
  1155. {
  1156.     st->declaration = DECL_NOMANGLE;
  1157.     st->scope = SCOPE_GLOBAL;
  1158. }
  1159. else
  1160.     st->token = TOK_IGNORE;
  1161. }
  1162.     } while (ok  &&  st->token == TOK_IGNORE);
  1164.     return ok;
  1165. }
  1167. /*----------------------------------------------------------------------------
  1168. *- Scanning functions
  1169. ----------------------------------------------------------------------------*/
  1171. /*  Parses the current file and decides whether to write out and tags that
  1172.  *  are discovered.
  1173.  */
  1174. extern boolean createTags( nesting, parent )
  1175.     const unsigned int nesting;
  1176.     const void *const parent;
  1177. {
  1178.     const tagScope declScope = File.isHeader ? SCOPE_GLOBAL : SCOPE_STATIC;
  1179.     statementInfo *st;
  1180.     boolean ok;
  1182.     DebugStatement( if (nesting > 0) debugParseNest(TRUE, nesting); )
  1183.     st = (statementInfo *)malloc(sizeof(statementInfo));
  1184.     if (st == NULL)
  1185. error(FATAL | PERROR, "cannot allocate statement info");
  1186.     initStatement(st, (const statementInfo *)parent);
  1188.     while ((ok = nextToken(st, nesting)))
  1189.     {
  1190. tagInfo *const tag = &activeTag(st);
  1192. if (st->token == TOK_EOF)
  1193.     break;
  1194. else if (! st->gotName)
  1195.     ;
  1196. else if (st->inEnumBody)
  1197.     qualifyEnumeratorTag(st, tag, declScope);
  1198. else if (st->token == TOK_BODY  &&  st->prev[0] == TOK_ARGS)
  1199.     qualifyFunctionTag(st, tag);
  1200. else if (st->token == TOK_SEMICOLON  ||  st->token == TOK_COMMA)
  1201. {
  1202.     if (st->scope == SCOPE_TYPEDEF)
  1203. makeTag(tag, &st->member, declScope, TAG_TYPEDEF);
  1204.     else if (st->prev[0] == TOK_NAME  ||  st->isFuncPtr)
  1205. qualifyVariableTag(st, tag);
  1206.     else if (st->prev[0] == TOK_ARGS)
  1207. qualifyFunctionDeclTag(st, tag);
  1208. }
  1210. /*  Reset after a semicolon, or BODY preceeded by ARGS (a function),
  1211.  *  a namspace definition, or an "extern" block.
  1212.  */
  1213. if (st->token == TOK_SEMICOLON  ||  (st->token == TOK_BODY  &&
  1214.      (st->declaration == DECL_NAMESPACE  ||
  1215.       st->declaration == DECL_NOMANGLE   ||
  1216.       st->prev[0] == TOK_ARGS)))
  1217. {
  1218.     DebugStatement( if (debug(DEBUG_PARSE)) printf("<ES>"); )
  1219.     reinitStatement(st);
  1220.     Cpp.resolveRequired = FALSE; /* end of statement */
  1221. }
  1222. else
  1223.     Cpp.resolveRequired = TRUE; /* in middle of statement */
  1225. st->prev[1] = st->prev[0];
  1226. st->prev[0] = st->token;
  1227.     }
  1228.     DebugStatement( if (nesting > 0) debugParseNest(FALSE, nesting - 1); )
  1229.     free(st);
  1230.     return ok;
  1231. }
  1233. extern void buildKeywordHash()
  1234. {
  1235.     int lastInitialChar = '';
  1236.     size_t i;
  1238.     /*  Clear all hash entries.
  1239.      */
  1240.     for (i = 0  ;  i < sizeof(KeywordHash)/sizeof(KeywordHash[0])  ;  ++i)
  1241. KeywordHash[i] = -1;
  1243.     /*  Set those hash entries corresponding to keywords.
  1244.      */
  1245.     for (i = 0  ;  i < KeywordTableSize  ;  ++i)
  1246.     {
  1247. const unsigned char initialChar = KeywordTable[i].name[0];
  1249. if (initialChar != lastInitialChar)
  1250. {
  1251.     KeywordHash[hashIndex(initialChar)] = i;
  1252.     lastInitialChar = initialChar;
  1253. }
  1254.     }
  1255. }
  1257. /* vi:set tabstop=8 shiftwidth=4: */