ctags/parsers/ruby.c

   1 /*
   2 *   Copyright (c) 2000-2001, Thaddeus Covert <sahuagin@mediaone.net>
   3 *   Copyright (c) 2002 Matthias Veit <matthias_veit@yahoo.de>
   4 *   Copyright (c) 2004 Elliott Hughes <enh@acm.org>
   5 *
   6 *   This source code is released for free distribution under the terms of the
   7 *   GNU General Public License version 2 or (at your option) any later version.
   8 *
   9 *   This module contains functions for generating tags for Ruby language
  10 *   files.
  11 */
  12
  13 /*
  14 *   INCLUDE FILES
  15 */
  16 #include "general.h"  /* must always come first */
  17
  18 #include <ctype.h>
  19 #include <string.h>
  20
  21 #include "debug.h"
  22 #include "entry.h"
  23 #include "parse.h"
  24 #include "nestlevel.h"
  25 #include "read.h"
  26 #include "routines.h"
  27 #include "strlist.h"
  28 #include "vstring.h"
  29
  30 /*
  31 *   DATA DECLARATIONS
  32 */
  33 typedef enum {
  34         K_UNDEFINED = -1,
  35         K_CLASS,
  36         K_METHOD,
  37         K_MODULE,
  38         K_SINGLETON,
  39         K_CONST,
  40         K_ACCESSOR,
  41         K_ALIAS,
  42         K_LIBRARY,
  43 } rubyKind;
  44
  45 typedef enum {
  46         RUBY_LIBRARY_REQUIRED,
  47         RUBY_LIBRARY_REQUIRED_REL,
  48         RUBY_LIBRARY_LOADED,
  49 } rubyLibraryRole;
  50
  51 /*
  52 *   DATA DEFINITIONS
  53 */
  54
  55 static roleDefinition RubyLibraryRoles [] = {
  56         { true, "required",  "loaded by \"require\" method" },
  57         { true, "requiredRel", "loaded by \"require_relative\" method" },
  58         { true, "loaded", "loaded by \"load\" method" },
  59 };
  60
  61 static kindDefinition RubyKinds [] = {
  62         { true, 'c', "class",  "classes" },
  63         { true, 'f', "method", "methods" },
  64         { true, 'm', "module", "modules" },
  65         { true, 'S', "singletonMethod", "singleton methods" },
  66         { true, 'C', "constant", "constants" },
  67         { true, 'A', "accessor", "accessors" },
  68         { true, 'a', "alias",    "aliases" },
  69         { true, 'L', "library",  "libraries",
  70           .referenceOnly = true, ATTACH_ROLES(RubyLibraryRoles) },
  71 };
  72
  73 typedef enum {
  74         F_MIXIN,
  75 } rubyField;
  76
  77 static fieldDefinition RubyFields[] = {
  78         { .name = "mixin",
  79           .description = "how the class or module is mixed in (mixin:HOW:MODULE)",
  80           .enabled = true },
  81 };
  82
  83 struct blockData {
  84         stringList *mixin;
  85 };
  86
  87 static NestingLevels* nesting = NULL;
  88
  89 #define SCOPE_SEPARATOR '.'
  90
  91 /*
  92 *   FUNCTION DEFINITIONS
  93 */
  94
  95 static void enterUnnamedScope (void);
  96
  97 /*
  98 * Returns a string describing the scope in 'nls'.
  99 * We record the current scope as a list of entered scopes.
 100 * Scopes corresponding to 'if' statements and the like are
 101 * represented by empty strings. Scopes corresponding to
 102 * modules and classes are represented by the name of the
 103 * module or class.
 104 */
 105 static vString* nestingLevelsToScope (const NestingLevels* nls)
 106 {
 107         int i;
 108         unsigned int chunks_output = 0;
 109         vString* result = vStringNew ();
 110         for (i = 0; i < nls->n; ++i)
 111         {
 112             NestingLevel *nl = nestingLevelsGetNthFromRoot (nls, i);
 113             tagEntryInfo *e = getEntryOfNestingLevel (nl);
 114             if (e && strlen (e->name) > 0 && (!e->placeholder))
 115             {
 116                 if (chunks_output++ > 0)
 117                     vStringPut (result, SCOPE_SEPARATOR);
 118                 vStringCatS (result, e->name);
 119             }
 120         }
 121         return result;
 122 }
 123
 124 /*
 125 * Attempts to advance 's' past 'literal'.
 126 * Returns true if it did, false (and leaves 's' where
 127 * it was) otherwise.
 128 */
 129 static bool canMatch (const unsigned char** s, const char* literal,
 130                          bool (*end_check) (int))
 131 {
 132         const int literal_length = strlen (literal);
 133         const int s_length = strlen ((const char *)*s);
 134
 135         if (s_length < literal_length)
 136                 return false;
 137
 138         const unsigned char next_char = *(*s + literal_length);
 139         if (strncmp ((const char*) *s, literal, literal_length) != 0)
 140         {
 141             return false;
 142         }
 143         /* Additionally check that we're at the end of a token. */
 144         if (! end_check (next_char))
 145         {
 146             return false;
 147         }
 148         *s += literal_length;
 149         return true;
 150 }
 151
 152 static bool isIdentChar (int c)
 153 {
 154         return (isalnum (c) || c == '_');
 155 }
 156
 157 static bool notIdentChar (int c)
 158 {
 159         return ! isIdentChar (c);
 160 }
 161
 162 static bool isOperatorChar (int c)
 163 {
 164         return (c == '[' || c == ']' ||
 165                 c == '=' || c == '!' || c == '~' ||
 166                 c == '+' || c == '-' ||
 167                 c == '@' || c == '*' || c == '/' || c == '%' ||
 168                 c == '<' || c == '>' ||
 169                 c == '&' || c == '^' || c == '|');
 170 }
 171
 172 static bool notOperatorChar (int c)
 173 {
 174         return ! isOperatorChar (c);
 175 }
 176
 177 static bool isSigilChar (int c)
 178 {
 179         return (c == '@' || c == '$');
 180 }
 181
 182 static bool isWhitespace (int c)
 183 {
 184         return c == 0 || isspace (c);
 185 }
 186
 187 /*
 188  * Advance 's' while the passed predicate is true. Returns true if
 189  * advanced by at least one position.
 190  */
 191 static bool advanceWhile (const unsigned char** s, bool (*predicate) (int))
 192 {
 193         const unsigned char* original_pos = *s;
 194
 195         while (**s != '\0')
 196         {
 197                 if (! predicate (**s))
 198                 {
 199                         return *s != original_pos;
 200                 }
 201
 202                 (*s)++;
 203         }
 204
 205         return *s != original_pos;
 206 }
 207
 208 static bool canMatchKeyword (const unsigned char** s, const char* literal)
 209 {
 210         return canMatch (s, literal, notIdentChar);
 211 }
 212
 213 /*
 214  * Extends canMatch. Works similarly, but allows assignment to precede
 215  * the keyword, as block assignment is a common Ruby idiom.
 216  */
 217 static bool canMatchKeywordWithAssign (const unsigned char** s, const char* literal)
 218 {
 219         const unsigned char* original_pos = *s;
 220
 221         if (canMatchKeyword (s, literal))
 222         {
 223                 return true;
 224         }
 225
 226         advanceWhile (s, isSigilChar);
 227
 228         if (! advanceWhile (s, isIdentChar))
 229         {
 230                 *s = original_pos;
 231                 return false;
 232         }
 233
 234         advanceWhile (s, isWhitespace);
 235
 236         if (! (advanceWhile (s, isOperatorChar) && *(*s - 1) == '='))
 237         {
 238                 *s = original_pos;
 239                 return false;
 240         }
 241
 242         advanceWhile (s, isWhitespace);
 243
 244         if (canMatchKeyword (s, literal))
 245         {
 246                 return true;
 247         }
 248
 249         *s = original_pos;
 250         return false;
 251 }
 252
 253 /*
 254 * Attempts to advance 'cp' past a Ruby operator method name. Returns
 255 * true if successful (and copies the name into 'name'), false otherwise.
 256 */
 257 static bool parseRubyOperator (vString* name, const unsigned char** cp)
 258 {
 259         static const char* RUBY_OPERATORS[] = {
 260             "[]", "[]=",
 261             "**",
 262             "!", "~", "+@", "-@",
 263             "*", "/", "%",
 264             "+", "-",
 265             ">>", "<<",
 266             "&",
 267             "^", "|",
 268             "<=", "<", ">", ">=",
 269             "<=>", "==", "===", "!=", "=~", "!~",
 270             "`",
 271             NULL
 272         };
 273         int i;
 274         for (i = 0; RUBY_OPERATORS[i] != NULL; ++i)
 275         {
 276             if (canMatch (cp, RUBY_OPERATORS[i], notOperatorChar))
 277             {
 278                 vStringCatS (name, RUBY_OPERATORS[i]);
 279                 return true;
 280             }
 281         }
 282         return false;
 283 }
 284
 285 /*
 286 * Emits a tag for the given 'name' of kind 'kind' at the current nesting.
 287 */
 288 static int emitRubyTagFull (vString* name, rubyKind kind, bool pushLevel, bool clearName)
 289 {
 290         tagEntryInfo tag;
 291         vString* scope;
 292         tagEntryInfo *parent;
 293         rubyKind parent_kind = K_UNDEFINED;
 294         NestingLevel *lvl;
 295         const char *unqualified_name;
 296         const char *qualified_name;
 297         int r;
 298
 299         if (!RubyKinds[kind].enabled) {
 300             return CORK_NIL;
 301         }
 302
 303         scope = nestingLevelsToScope (nesting);
 304         lvl = nestingLevelsGetCurrent (nesting);
 305         parent = getEntryOfNestingLevel (lvl);
 306         if (parent)
 307                 parent_kind =  parent->kindIndex;
 308
 309         qualified_name = vStringValue (name);
 310         unqualified_name = strrchr (qualified_name, SCOPE_SEPARATOR);
 311         if (unqualified_name && unqualified_name[1])
 312         {
 313                 if (unqualified_name > qualified_name)
 314                 {
 315                         if (vStringLength (scope) > 0)
 316                                 vStringPut (scope, SCOPE_SEPARATOR);
 317                         vStringNCatS (scope, qualified_name,
 318                                       unqualified_name - qualified_name);
 319                         /* assume module parent type for a lack of a better option */
 320                         parent_kind = K_MODULE;
 321                 }
 322                 unqualified_name++;
 323         }
 324         else
 325                 unqualified_name = qualified_name;
 326
 327         initTagEntry (&tag, unqualified_name, kind);
 328
 329         /* Don't fill the scope field for a tag entry representing
 330          * a global variable. */
 331         if (unqualified_name[0] != '$'
 332                 && vStringLength (scope) > 0) {
 333                 Assert (0 <= parent_kind &&
 334                         (size_t) parent_kind < (ARRAY_SIZE (RubyKinds)));
 335
 336                 tag.extensionFields.scopeKindIndex = parent_kind;
 337                 tag.extensionFields.scopeName = vStringValue (scope);
 338         }
 339         r = makeTagEntry (&tag);
 340
 341         if (pushLevel)
 342                 nestingLevelsPush (nesting, r);
 343
 344         if (clearName)
 345                 vStringClear (name);
 346         vStringDelete (scope);
 347
 348         return r;
 349 }
 350
 351 static int emitRubyTag (vString* name, rubyKind kind)
 352 {
 353         return emitRubyTagFull (name, kind, kind != K_CONST, true);
 354 }
 355
 356 /* Tests whether 'ch' is a character in 'list'. */
 357 static bool charIsIn (char ch, const char* list)
 358 {
 359         return (strchr (list, ch) != NULL);
 360 }
 361
 362 /* Advances 'cp' over leading whitespace. */
 363 static void skipWhitespace (const unsigned char** cp)
 364 {
 365         while (isspace (**cp))
 366         {
 367             ++*cp;
 368         }
 369 }
 370
 371 /*
 372 * Copies the characters forming an identifier from *cp into
 373 * name, leaving *cp pointing to the character after the identifier.
 374 */
 375 static rubyKind parseIdentifier (
 376                 const unsigned char** cp, vString* name, rubyKind kind)
 377 {
 378         /* Method names are slightly different to class and variable names.
 379          * A method name may optionally end with a question mark, exclamation
 380          * point or equals sign. These are all part of the name.
 381          * A method name may also contain a period if it's a singleton method.
 382          */
 383         bool had_sep = false;
 384         const char* also_ok;
 385         if (kind == K_METHOD)
 386         {
 387                 also_ok = ".?!=";
 388         }
 389         else if (kind == K_SINGLETON)
 390         {
 391                 also_ok = "?!=";
 392         }
 393         else
 394         {
 395                 also_ok = "";
 396         }
 397
 398         skipWhitespace (cp);
 399
 400         /* Check for an anonymous (singleton) class such as "class << HTTP". */
 401         if (kind == K_CLASS && **cp == '<' && *(*cp + 1) == '<')
 402         {
 403                 return K_UNDEFINED;
 404         }
 405
 406         /* Check for operators such as "def []=(key, val)". */
 407         if (kind == K_METHOD || kind == K_SINGLETON)
 408         {
 409                 if (parseRubyOperator (name, cp))
 410                 {
 411                         return kind;
 412                 }
 413         }
 414
 415         /* Copy the identifier into 'name'. */
 416         while (**cp != 0 && (**cp == ':' || isIdentChar (**cp) || charIsIn (**cp, also_ok)))
 417         {
 418                 char last_char = **cp;
 419
 420                 if (last_char == ':')
 421                         had_sep = true;
 422                 else
 423                 {
 424                         if (had_sep)
 425                         {
 426                                 vStringPut (name, SCOPE_SEPARATOR);
 427                                 had_sep = false;
 428                         }
 429                         vStringPut (name, last_char);
 430                 }
 431                 ++*cp;
 432
 433                 if (kind == K_METHOD)
 434                 {
 435                         /* Recognize singleton methods. */
 436                         if (last_char == '.')
 437                         {
 438                                 vStringClear (name);
 439                                 return parseIdentifier (cp, name, K_SINGLETON);
 440                         }
 441                 }
 442
 443                 if (kind == K_METHOD || kind == K_SINGLETON)
 444                 {
 445                         /* Recognize characters which mark the end of a method name. */
 446                         if (charIsIn (last_char, "?!="))
 447                         {
 448                                 break;
 449                         }
 450                 }
 451         }
 452         return kind;
 453 }
 454
 455 static void parseString (const unsigned char** cp, unsigned char boundary, vString* vstr)
 456 {
 457         while (**cp != 0 && **cp != boundary)
 458         {
 459                 if (vstr)
 460                         vStringPut (vstr, **cp);
 461                 ++*cp;
 462         }
 463
 464         /* skip the last found '"' */
 465         if (**cp == boundary)
 466                 ++*cp;
 467 }
 468
 469 static void parseSignature (const unsigned char** cp, vString* vstr)
 470 {
 471         int depth = 1;
 472
 473         while (1)
 474         {
 475                 /* FIXME:
 476                  * - handle string literals including ( or ), and
 477                  * - skip comments.
 478                  */
 479                 while (! (depth == 0 || **cp == '\0'))
 480                 {
 481                         if (**cp == '(' || **cp == ')')
 482                         {
 483                                 depth += (**cp == '(')? 1: -1;
 484                                 vStringPut (vstr, **cp);
 485                         }
 486                         else if (**cp == '#')
 487                         {
 488                                 ++*cp;
 489                                 while (**cp != '\0')
 490                                         ++*cp;
 491                                 break;
 492                         }
 493                         else if (**cp == '\'' || **cp == '"')
 494                         {
 495                                 unsigned char b = **cp;
 496                                 vStringPut (vstr, b);
 497                                 ++*cp;
 498                                 parseString (cp, b, vstr);
 499                                 vStringPut (vstr, b);
 500                                 continue;
 501                         }
 502                         else if (isspace (vStringLast (vstr)))
 503                         {
 504                                 if (! (isspace (**cp)))
 505                                 {
 506                                         if (**cp == ',')
 507                                                 vStringChop (vstr);
 508                                         vStringPut (vstr, **cp);
 509                                 }
 510                         }
 511                         else
 512                                 vStringPut (vstr, **cp);
 513                         ++*cp;
 514                 }
 515                 if (depth == 0)
 516                         return;
 517
 518                 const unsigned char *line = readLineFromInputFile ();
 519                 if (line == NULL)
 520                         return;
 521                 else
 522                         *cp = line;
 523         }
 524 }
 525
 526 static int readAndEmitTagFull (const unsigned char** cp, rubyKind expected_kind,
 527                                                            bool pushLevel, bool clearName)
 528 {
 529         int r = CORK_NIL;
 530         if (isspace (**cp))
 531         {
 532                 vString *name = vStringNew ();
 533                 rubyKind actual_kind = parseIdentifier (cp, name, expected_kind);
 534
 535                 if (actual_kind == K_UNDEFINED || vStringLength (name) == 0)
 536                 {
 537                         /*
 538                         * What kind of tags should we create for code like this?
 539                         *
 540                         *    %w(self.clfloor clfloor).each do |name|
 541                         *        module_eval <<-"end;"
 542                         *            def #{name}(x, y=1)
 543                         *                q, r = x.divmod(y)
 544                         *                q = q.to_i
 545                         *                return q, r
 546                         *            end
 547                         *        end;
 548                         *    end
 549                         *
 550                         * Or this?
 551                         *
 552                         *    class << HTTP
 553                         *
 554                         * For now, we don't create any.
 555                         */
 556                         enterUnnamedScope ();
 557                 }
 558                 else
 559                 {
 560                         r = emitRubyTagFull (name, actual_kind, pushLevel, clearName);
 561                 }
 562                 vStringDelete (name);
 563         }
 564         return r;
 565 }
 566
 567 static int readAndEmitTag (const unsigned char** cp, rubyKind expected_kind)
 568 {
 569         return readAndEmitTagFull (cp, expected_kind, expected_kind != K_CONST, true);
 570 }
 571
 572 static void readAndStoreMixinSpec (const unsigned char** cp, const char *how_mixin)
 573 {
 574
 575         NestingLevel *nl = NULL;
 576         tagEntryInfo *e = NULL;
 577         int ownerLevel = 0;
 578
 579         for (ownerLevel = 0; ownerLevel < nesting->n; ownerLevel++)
 580         {
 581                 nl = nestingLevelsGetNthParent (nesting, ownerLevel);
 582                 e = nl? getEntryOfNestingLevel (nl): NULL;
 583
 584                 /* Ignore "if", "unless", "while" ... */
 585                 if ((nl && (nl->corkIndex == CORK_NIL)) || (e && e->placeholder))
 586                         continue;
 587                 break;
 588         }
 589
 590         if (!e)
 591                 return;
 592
 593         if (e->kindIndex == K_SINGLETON)
 594         {
 595                 nl = nestingLevelsGetNthParent (nesting,
 596                                                                                 ownerLevel + 1);
 597                 if (nl == NULL)
 598                         return;
 599                 e = getEntryOfNestingLevel (nl);
 600         }
 601
 602         if (!e)
 603                 return;
 604
 605         if (! (e->kindIndex == K_CLASS || e->kindIndex == K_MODULE))
 606                 return;
 607
 608         if (isspace (**cp) || (**cp == '('))
 609         {
 610                 if (isspace (**cp))
 611                         skipWhitespace (cp);
 612                 if (**cp == '(')
 613                         ++*cp;
 614
 615                 vString *spec = vStringNewInit (how_mixin);
 616                 vStringPut(spec, ':');
 617
 618                 size_t len = vStringLength (spec);
 619                 parseIdentifier (cp, spec, K_MODULE);
 620                 if (len == vStringLength (spec))
 621                 {
 622                         vStringDelete (spec);
 623                         return;
 624                 }
 625
 626                 struct blockData *bdata =  nestingLevelGetUserData (nl);
 627                 if (bdata->mixin == NULL)
 628                         bdata->mixin = stringListNew ();
 629                 stringListAdd (bdata->mixin, spec);
 630         }
 631 }
 632
 633 static void enterUnnamedScope (void)
 634 {
 635         int r = CORK_NIL;
 636         NestingLevel *parent = nestingLevelsGetCurrent (nesting);
 637         tagEntryInfo *e_parent = getEntryOfNestingLevel (parent);
 638
 639         if (e_parent)
 640         {
 641                 tagEntryInfo e;
 642                 initTagEntry (&e, "", e_parent->kindIndex);
 643                 e.placeholder = 1;
 644                 r = makeTagEntry (&e);
 645         }
 646         nestingLevelsPush (nesting, r);
 647 }
 648
 649 static void attachMixinField (int corkIndex, stringList *mixinSpec)
 650 {
 651         vString *mixinField = stringListItem (mixinSpec, 0);
 652         for (unsigned int i = 1; i < stringListCount (mixinSpec); i++)
 653         {
 654                 vStringPut (mixinField, ',');
 655                 vStringCat (mixinField, stringListItem (mixinSpec, i));
 656         }
 657
 658         attachParserFieldToCorkEntry (corkIndex, RubyFields [F_MIXIN].ftype,
 659                                                                   vStringValue (mixinField));
 660 }
 661
 662 static void deleteBlockData (NestingLevel *nl)
 663 {
 664         struct blockData *bdata = nestingLevelGetUserData (nl);
 665
 666         if (nl->corkIndex != CORK_NIL
 667                 && bdata->mixin != NULL
 668                 && stringListCount (bdata->mixin) > 0)
 669                 attachMixinField (nl->corkIndex, bdata->mixin);
 670
 671         tagEntryInfo *e = getEntryInCorkQueue (nl->corkIndex);
 672         if (e && !e->placeholder)
 673                         e->extensionFields.endLine = getInputLineNumber ();
 674
 675         if (bdata->mixin)
 676                 stringListDelete (bdata->mixin);
 677 }
 678
 679 static bool doesLineIncludeConstant (const unsigned char **cp, vString *constant)
 680 {
 681         const unsigned char **p = cp;
 682
 683         if (isspace (**p))
 684                 skipWhitespace (p);
 685
 686         if (isupper (**p))
 687         {
 688                 while (**p != 0 && isIdentChar (**p))
 689                 {
 690                         vStringPut (constant, **p);
 691                         ++*p;
 692                 }
 693                 if (isspace (**p))
 694                         skipWhitespace (p);
 695
 696                 if (**p == '=')
 697                 {
 698                         *cp = *p;
 699                         return true;
 700                 }
 701                 vStringClear (constant);
 702         }
 703
 704         return false;
 705 }
 706
 707 static void emitRubyAccessorTags (vString *a, bool reader, bool writer)
 708 {
 709         if (vStringLength (a) == 0)
 710                 return;
 711
 712         if (reader)
 713                 emitRubyTagFull (a, K_ACCESSOR, false, !writer);
 714         if (writer)
 715         {
 716                 vStringPut (a, '=');
 717                 emitRubyTagFull (a, K_ACCESSOR, false, true);
 718         }
 719 }
 720
 721 static void readAttrsAndEmitTags (const unsigned char **cp, bool reader, bool writer)
 722 {
 723         vString *a = vStringNew ();
 724
 725         skipWhitespace (cp);
 726         if (**cp == '(')
 727                 ++*cp;
 728
 729         do {
 730                 skipWhitespace (cp);
 731                 if (**cp == ':')
 732                 {
 733                         ++*cp;
 734                         if (K_METHOD == parseIdentifier (cp, a, K_METHOD))
 735                         {
 736                                 emitRubyAccessorTags (a, reader, writer);
 737                                 skipWhitespace (cp);
 738                                 if (**cp == ',')
 739                                 {
 740                                         ++*cp;
 741                                         continue;
 742                                 }
 743                         }
 744                 }
 745                 else if (**cp == '"' || **cp == '\'')
 746                 {
 747                         unsigned char b = **cp;
 748                         ++*cp;
 749                         parseString (cp, b, a);
 750
 751                         emitRubyAccessorTags (a, reader, writer);
 752                         skipWhitespace (cp);
 753                         if (**cp == ',')
 754                         {
 755                                 ++*cp;
 756                                 continue;
 757                         }
 758                 }
 759                 break;
 760         } while (1);
 761
 762         vStringDelete (a);
 763 }
 764
 765 static int readAliasMethodAndEmitTags (const unsigned char **cp)
 766 {
 767         int r = CORK_NIL;
 768         vString *a = vStringNew ();
 769
 770         skipWhitespace (cp);
 771         if (**cp == '(')
 772                 ++*cp;
 773
 774         skipWhitespace (cp);
 775         if (**cp == ':')
 776         {
 777                 ++*cp;
 778                 if (K_METHOD != parseIdentifier (cp, a, K_METHOD))
 779                         vStringClear (a);
 780         }
 781         else if (**cp == '"' || **cp == '\'')
 782         {
 783                 unsigned char b = **cp;
 784                 ++*cp;
 785                 parseString (cp, b, a);
 786         }
 787
 788         if (vStringLength (a) > 0)
 789                 r = emitRubyTagFull (a, K_ALIAS, false, false);
 790
 791         vStringDelete (a);
 792         return r;
 793 }
 794
 795 static int readStringAndEmitTag (const unsigned char **cp, rubyKind kind, int role)
 796 {
 797         int r = CORK_NIL;
 798         vString *s = NULL;
 799
 800         skipWhitespace (cp);
 801         if (**cp == '(')
 802                 ++*cp;
 803
 804         skipWhitespace (cp);
 805         if (**cp == '"' || **cp == '\'')
 806         {
 807                 unsigned char b = **cp;
 808                 ++*cp;
 809                 s = vStringNew ();
 810                 parseString (cp, b, s);
 811         }
 812
 813         if (s && vStringLength (s) > 0)
 814                 r = makeSimpleRefTag (s, kind, role);
 815
 816         vStringDelete (s);
 817         return r;
 818 }
 819
 820 static int readAndEmitDef (const unsigned char **cp)
 821 {
 822         rubyKind kind = K_METHOD;
 823         NestingLevel *nl = nestingLevelsGetCurrent (nesting);
 824         tagEntryInfo *e_scope  = getEntryOfNestingLevel (nl);
 825
 826         /* if the def is inside an unnamed scope at the class level, assume
 827          * it's from a singleton from a construct like this:
 828          *
 829          * class C
 830          *   class << self
 831          *     def singleton
 832          *       ...
 833          *     end
 834          *   end
 835          * end
 836          */
 837         if (e_scope && e_scope->kindIndex == K_CLASS && strlen (e_scope->name) == 0)
 838                 kind = K_SINGLETON;
 839         int corkIndex = readAndEmitTag (cp, kind);
 840         tagEntryInfo *e = getEntryInCorkQueue (corkIndex);
 841
 842         /* Fill signature: field. */
 843         if (e)
 844         {
 845                 vString *signature = vStringNewInit ("(");
 846                 skipWhitespace (cp);
 847                 if (**cp == '(')
 848                 {
 849                         ++(*cp);
 850                         parseSignature (cp, signature);
 851                         if (vStringLast(signature) != ')')
 852                         {
 853                                 vStringDelete (signature);
 854                                 signature = NULL;
 855                         }
 856                 }
 857                 else
 858                         vStringPut (signature, ')');
 859                 e->extensionFields.signature = vStringDeleteUnwrap (signature);
 860                 signature = NULL;;
 861                 vStringDelete (signature);
 862         }
 863         return corkIndex;
 864 }
 865
 866 static void findRubyTags (void)
 867 {
 868         const unsigned char *line;
 869         bool inMultiLineComment = false;
 870         vString *constant = vStringNew ();
 871
 872         nesting = nestingLevelsNewFull (sizeof (struct blockData), deleteBlockData);
 873
 874         /* FIXME: this whole scheme is wrong, because Ruby isn't line-based.
 875         * You could perfectly well write:
 876         *
 877         *  def
 878         *  method
 879         *   puts("hello")
 880         *  end
 881         *
 882         * if you wished, and this function would fail to recognize anything.
 883         */
 884         while ((line = readLineFromInputFile ()) != NULL)
 885         {
 886                 const unsigned char *cp = line;
 887                 /* if we expect a separator after a while, for, or until statement
 888                  * separators are "do", ";" or newline */
 889                 bool expect_separator = false;
 890
 891                 if (canMatch (&cp, "=begin", isWhitespace))
 892                 {
 893                         inMultiLineComment = true;
 894                         continue;
 895                 }
 896                 if (canMatch (&cp, "=end", isWhitespace))
 897                 {
 898                         inMultiLineComment = false;
 899                         continue;
 900                 }
 901                 if (inMultiLineComment)
 902                         continue;
 903
 904                 skipWhitespace (&cp);
 905
 906                 /* Avoid mistakenly starting a scope for modifiers such as
 907                 *
 908                 *   return if <exp>
 909                 *
 910                 * FIXME: we're fooled if someone does something heinous such as
 911                 *
 912                 *   puts("hello") \
 913                 *       unless <exp>
 914                 */
 915
 916                 if (canMatchKeywordWithAssign (&cp, "for") ||
 917                     canMatchKeywordWithAssign (&cp, "until") ||
 918                     canMatchKeywordWithAssign (&cp, "while"))
 919                 {
 920                         expect_separator = true;
 921                         enterUnnamedScope ();
 922                 }
 923                 else if (canMatchKeywordWithAssign (&cp, "case") ||
 924                          canMatchKeywordWithAssign (&cp, "if") ||
 925                          canMatchKeywordWithAssign (&cp, "unless"))
 926                 {
 927                         enterUnnamedScope ();
 928                 }
 929
 930                 /*
 931                 * "module M", "class C" and "def m" should only be at the beginning
 932                 * of a line.
 933                 */
 934                 if (canMatchKeywordWithAssign (&cp, "module"))
 935                 {
 936                         readAndEmitTag (&cp, K_MODULE);
 937                 }
 938                 else if (canMatchKeywordWithAssign (&cp, "class"))
 939                 {
 940                         int r = readAndEmitTag (&cp, K_CLASS);
 941                         tagEntryInfo *e = getEntryInCorkQueue (r);
 942
 943                         if (e)
 944                         {
 945                                 skipWhitespace (&cp);
 946                                 if (*cp == '<' && *(cp + 1) != '<')
 947                                 {
 948                                         cp++;
 949                                         vString *parent = vStringNew ();
 950                                         parseIdentifier (&cp, parent, K_CLASS);
 951                                         if (vStringLength (parent) > 0)
 952                                                 e->extensionFields.inheritance = vStringDeleteUnwrap (parent);
 953                                         else
 954                                                 vStringDelete (parent);
 955                                 }
 956                         }
 957                 }
 958                 else if (canMatchKeywordWithAssign (&cp, "include"))
 959                 {
 960                         readAndStoreMixinSpec (&cp, "include");
 961                 }
 962                 else if (canMatchKeywordWithAssign (&cp, "prepend"))
 963                 {
 964                         readAndStoreMixinSpec (&cp, "prepend");
 965                 }
 966                 else if (canMatchKeywordWithAssign (&cp, "extend"))
 967                 {
 968                         readAndStoreMixinSpec (&cp, "extend");
 969                 }
 970                 else if (canMatchKeywordWithAssign (&cp, "def"))
 971                 {
 972                         readAndEmitDef (&cp);
 973                 }
 974                 else if (canMatchKeywordWithAssign (&cp, "attr_reader"))
 975                 {
 976                         readAttrsAndEmitTags (&cp, true, false);
 977                 }
 978                 else if (canMatchKeywordWithAssign (&cp, "attr_writer"))
 979                 {
 980                         readAttrsAndEmitTags (&cp, false, true);
 981                 }
 982                 else if (canMatchKeywordWithAssign (&cp, "attr_accessor"))
 983                 {
 984                         readAttrsAndEmitTags (&cp, true, true);
 985                 }
 986                 else if (doesLineIncludeConstant (&cp, constant))
 987                 {
 988                         emitRubyTag (constant, K_CONST);
 989                         vStringClear (constant);
 990                 }
 991                 else if (canMatchKeywordWithAssign (&cp, "require"))
 992                 {
 993                         readStringAndEmitTag (&cp, K_LIBRARY, RUBY_LIBRARY_REQUIRED);
 994                 }
 995                 else if (canMatchKeywordWithAssign (&cp, "require_relative"))
 996                 {
 997                         readStringAndEmitTag (&cp, K_LIBRARY, RUBY_LIBRARY_REQUIRED_REL);
 998                 }
 999                 else if (canMatchKeywordWithAssign (&cp, "load"))
1000                 {
1001                         readStringAndEmitTag (&cp, K_LIBRARY, RUBY_LIBRARY_LOADED);
1002                 }
1003                 else if (canMatchKeywordWithAssign (&cp, "alias"))
1004                 {
1005                         if (!readAndEmitTagFull (&cp, K_ALIAS, false, true)
1006                                 && (*cp == '$'))
1007                         {
1008                                 /* Alias for a global variable. */
1009                                 ++cp;
1010                                 vString *alias = vStringNew ();
1011                                 vStringPut (alias, '$');
1012                                 if (K_METHOD == parseIdentifier (&cp, alias, K_METHOD)
1013                                         && vStringLength (alias) > 0)
1014                                         emitRubyTagFull (alias, K_ALIAS, false, false);
1015                                 vStringDelete (alias);
1016                         }
1017                 }
1018                 else if (canMatchKeywordWithAssign (&cp, "alias_method"))
1019                         readAliasMethodAndEmitTags (&cp);
1020                 else if ((canMatchKeywordWithAssign (&cp, "private")
1021                                   || canMatchKeywordWithAssign (&cp, "protected")
1022                                   || canMatchKeywordWithAssign (&cp, "public")
1023                                   || canMatchKeywordWithAssign (&cp, "private_class_method")
1024                                   || canMatchKeywordWithAssign (&cp, "public_class_method")))
1025                 {
1026                         skipWhitespace (&cp);
1027                         if (canMatchKeywordWithAssign (&cp, "def"))
1028                                 readAndEmitDef (&cp);
1029                         /* TODO: store the method for controlling visibility
1030                          * to the "access:" field of the tag.*/
1031                 }
1032
1033
1034                 while (*cp != '\0')
1035                 {
1036                         /* FIXME: we don't cope with here documents,
1037                         * or regular expression literals, or ... you get the idea.
1038                         * Hopefully, the restriction above that insists on seeing
1039                         * definitions at the starts of lines should keep us out of
1040                         * mischief.
1041                         */
1042                         if (inMultiLineComment || isspace (*cp))
1043                         {
1044                                 ++cp;
1045                         }
1046                         else if (*cp == '#')
1047                         {
1048                                 /* FIXME: this is wrong, but there *probably* won't be a
1049                                 * definition after an interpolated string (where # doesn't
1050                                 * mean 'comment').
1051                                 */
1052                                 break;
1053                         }
1054                         else if (canMatchKeyword (&cp, "begin"))
1055                         {
1056                                 enterUnnamedScope ();
1057                         }
1058                         else if (canMatchKeyword (&cp, "do"))
1059                         {
1060                                 if (! expect_separator)
1061                                         enterUnnamedScope ();
1062                                 else
1063                                         expect_separator = false;
1064                         }
1065                         else if (canMatchKeyword (&cp, "end") && nesting->n > 0)
1066                         {
1067                                 /* Leave the most recent scope. */
1068                                 nestingLevelsPop (nesting);
1069                         }
1070                         else if (*cp == '"' || *cp == '\'')
1071                         {
1072                                 unsigned char b = *cp;
1073                                 /* Skip string literals.
1074                                  * FIXME: should cope with escapes and interpolation.
1075                                  */
1076                                 ++cp;
1077                                 parseString (&cp, b, NULL);
1078                         }
1079                         else if (*cp == ';')
1080                         {
1081                                 ++cp;
1082                                 expect_separator = false;
1083                         }
1084                         else if (*cp != '\0')
1085                         {
1086                                 do
1087                                         ++cp;
1088                                 while (isIdentChar (*cp));
1089                         }
1090                 }
1091         }
1092         nestingLevelsFree (nesting);
1093         vStringDelete (constant);
1094 }
1095
1096 extern parserDefinition* RubyParser (void)
1097 {
1098         static const char *const extensions [] = { "rb", "ruby", NULL };
1099         parserDefinition* def = parserNew ("Ruby");
1100         def->kindTable      = RubyKinds;
1101         def->kindCount  = ARRAY_SIZE (RubyKinds);
1102         def->extensions = extensions;
1103         def->parser     = findRubyTags;
1104         def->fieldTable = RubyFields;
1105         def->fieldCount = ARRAY_SIZE (RubyFields);
1106         def->useCork    = CORK_QUEUE;
1107         return def;
1108 }