summaryrefslogtreecommitdiff
path: root/lib/rdoc/parser/c.rb
blob: a2c3eefbde8c0c0cf44bfa22c44e6fdabc297e8e (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
require 'rdoc/parser'
require 'rdoc/parser/ruby'
require 'rdoc/known_classes'

##
# We attempt to parse C extension files. Basically we look for
# the standard patterns that you find in extensions: <tt>rb_define_class,
# rb_define_method</tt> and so on. We also try to find the corresponding
# C source for the methods and extract comments, but if we fail
# we don't worry too much.
#
# The comments associated with a Ruby method are extracted from the C
# comment block associated with the routine that _implements_ that
# method, that is to say the method whose name is given in the
# <tt>rb_define_method</tt> call. For example, you might write:
#
#  /*
#   * Returns a new array that is a one-dimensional flattening of this
#   * array (recursively). That is, for every element that is an array,
#   * extract its elements into the new array.
#   *
#   *    s = [ 1, 2, 3 ]           #=> [1, 2, 3]
#   *    t = [ 4, 5, 6, [7, 8] ]   #=> [4, 5, 6, [7, 8]]
#   *    a = [ s, t, 9, 10 ]       #=> [[1, 2, 3], [4, 5, 6, [7, 8]], 9, 10]
#   *    a.flatten                 #=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
#   */
#   static VALUE
#   rb_ary_flatten(ary)
#       VALUE ary;
#   {
#       ary = rb_obj_dup(ary);
#       rb_ary_flatten_bang(ary);
#       return ary;
#   }
#
#   ...
#
#   void
#   Init_Array()
#   {
#     ...
#     rb_define_method(rb_cArray, "flatten", rb_ary_flatten, 0);
#
# Here RDoc will determine from the rb_define_method line that there's a
# method called "flatten" in class Array, and will look for the implementation
# in the method rb_ary_flatten. It will then use the comment from that
# method in the HTML output. This method must be in the same source file
# as the rb_define_method.
#
# C classes can be diagrammed (see /tc/dl/ruby/ruby/error.c), and RDoc
# integrates C and Ruby source into one tree
#
# The comment blocks may include special directives:
#
# [Document-class: <i>name</i>]
#   This comment block is documentation for the given class. Use this
#   when the <tt>Init_xxx</tt> method is not named after the class.
#
# [Document-method: <i>name</i>]
#   This comment documents the named method. Use when RDoc cannot
#   automatically find the method from it's declaration
#
# [call-seq:  <i>text up to an empty line</i>]
#   Because C source doesn't give descripive names to Ruby-level parameters,
#   you need to document the calling sequence explicitly
#
# In addition, RDoc assumes by default that the C method implementing a
# Ruby function is in the same source file as the rb_define_method call.
# If this isn't the case, add the comment:
#
#    rb_define_method(....);  // in filename
#
# As an example, we might have an extension that defines multiple classes
# in its Init_xxx method. We could document them using
#
#   /*
#    * Document-class:  MyClass
#    *
#    * Encapsulate the writing and reading of the configuration
#    * file. ...
#    */
#
#   /*
#    * Document-method: read_value
#    *
#    * call-seq:
#    *   cfg.read_value(key)            -> value
#    *   cfg.read_value(key} { |key| }  -> value
#    *
#    * Return the value corresponding to +key+ from the configuration.
#    * In the second form, if the key isn't found, invoke the
#    * block and return its value.
#    */

class RDoc::Parser::C < RDoc::Parser

  parse_files_matching(/\.(?:([CcHh])\1?|c([+xp])\2|y)\z/)

  @@enclosure_classes = {}
  @@known_bodies = {}

  ##
  # Prepare to parse a C file

  def initialize(top_level, file_name, content, options, stats)
    super

    @known_classes = RDoc::KNOWN_CLASSES.dup
    @content = handle_tab_width handle_ifdefs_in(@content)
    @classes = Hash.new
    @file_dir = File.dirname(@file_name)
  end

  def do_aliases
    @content.scan(%r{rb_define_alias\s*\(\s*(\w+),\s*"([^"]+)",\s*"([^"]+)"\s*\)}m) do
      |var_name, new_name, old_name|
      class_name = @known_classes[var_name] || var_name
      class_obj  = find_class(var_name, class_name)

      as = class_obj.add_alias RDoc::Alias.new("", old_name, new_name, "")

      @stats.add_alias as
    end
  end

  def do_classes
    @content.scan(/(\w+)\s* = \s*rb_define_module\s*\(\s*"(\w+)"\s*\)/mx) do
      |var_name, class_name|
      handle_class_module(var_name, "module", class_name, nil, nil)
    end

    # The '.' lets us handle SWIG-generated files
    @content.scan(/([\w\.]+)\s* = \s*rb_define_class\s*
              \(
                 \s*"(\w+)",
                 \s*(\w+)\s*
              \)/mx) do |var_name, class_name, parent|
      handle_class_module(var_name, "class", class_name, parent, nil)
    end

    @content.scan(/(\w+)\s*=\s*boot_defclass\s*\(\s*"(\w+?)",\s*(\w+?)\s*\)/) do
      |var_name, class_name, parent|
      parent = nil if parent == "0"
      handle_class_module(var_name, "class", class_name, parent, nil)
    end

    @content.scan(/(\w+)\s* = \s*rb_define_module_under\s*
              \(
                 \s*(\w+),
                 \s*"(\w+)"
              \s*\)/mx) do |var_name, in_module, class_name|
      handle_class_module(var_name, "module", class_name, nil, in_module)
    end

    @content.scan(/([\w\.]+)\s* = \s*rb_define_class_under\s*
              \(
                 \s*(\w+),
                 \s*"(\w+)",
                 \s*([\w\*\s\(\)\.\->]+)\s*  # for SWIG
              \s*\)/mx) do |var_name, in_module, class_name, parent|
      handle_class_module(var_name, "class", class_name, parent, in_module)
    end
  end

  def do_constants
    @content.scan(%r{\Wrb_define_
                   (
                      variable |
                      readonly_variable |
                      const |
                      global_const |
                    )
               \s*\(
                 (?:\s*(\w+),)?
                 \s*"(\w+)",
                 \s*(.*?)\s*\)\s*;
                 }xm) do |type, var_name, const_name, definition|
      var_name = "rb_cObject" if !var_name or var_name == "rb_mKernel"
      handle_constants(type, var_name, const_name, definition)
    end
  end

  ##
  # Look for includes of the form:
  #
  #   rb_include_module(rb_cArray, rb_mEnumerable);

  def do_includes
    @content.scan(/rb_include_module\s*\(\s*(\w+?),\s*(\w+?)\s*\)/) do |c,m|
      if cls = @classes[c]
        m = @known_classes[m] || m
        cls.add_include RDoc::Include.new(m, "")
      end
    end
  end

  def do_methods
    @content.scan(%r{rb_define_
                   (
                      singleton_method |
                      method           |
                      module_function  |
                      private_method
                   )
                   \s*\(\s*([\w\.]+),
                     \s*"([^"]+)",
                     \s*(?:RUBY_METHOD_FUNC\(|VALUEFUNC\()?(\w+)\)?,
                     \s*(-?\w+)\s*\)
                   (?:;\s*/[*/]\s+in\s+(\w+?\.[cy]))?
                 }xm) do
      |type, var_name, meth_name, meth_body, param_count, source_file|

      # Ignore top-object and weird struct.c dynamic stuff
      next if var_name == "ruby_top_self"
      next if var_name == "nstr"
      next if var_name == "envtbl"
      next if var_name == "argf"   # it'd be nice to handle this one

      var_name = "rb_cObject" if var_name == "rb_mKernel"
      handle_method(type, var_name, meth_name,
                    meth_body, param_count, source_file)
    end

    @content.scan(%r{rb_define_attr\(
                             \s*([\w\.]+),
                             \s*"([^"]+)",
                             \s*(\d+),
                             \s*(\d+)\s*\);
                }xm) do |var_name, attr_name, attr_reader, attr_writer|
      #var_name = "rb_cObject" if var_name == "rb_mKernel"
      handle_attr(var_name, attr_name,
                  attr_reader.to_i != 0,
                  attr_writer.to_i != 0)
    end

    @content.scan(%r{rb_define_global_function\s*\(
                             \s*"([^"]+)",
                             \s*(?:RUBY_METHOD_FUNC\(|VALUEFUNC\()?(\w+)\)?,
                             \s*(-?\w+)\s*\)
                (?:;\s*/[*/]\s+in\s+(\w+?\.[cy]))?
                }xm) do |meth_name, meth_body, param_count, source_file|
      handle_method("method", "rb_mKernel", meth_name,
                    meth_body, param_count, source_file)
    end

    @content.scan(/define_filetest_function\s*\(
                             \s*"([^"]+)",
                             \s*(?:RUBY_METHOD_FUNC\(|VALUEFUNC\()?(\w+)\)?,
                             \s*(-?\w+)\s*\)/xm) do
      |meth_name, meth_body, param_count|

      handle_method("method", "rb_mFileTest", meth_name, meth_body, param_count)
      handle_method("singleton_method", "rb_cFile", meth_name, meth_body, param_count)
    end
  end

  def find_attr_comment(attr_name)
    if @content =~ %r{((?>/\*.*?\*/\s+))
                   rb_define_attr\((?:\s*(\w+),)?\s*"#{attr_name}"\s*,.*?\)\s*;}xmi
      $1
    elsif @content =~ %r{Document-attr:\s#{attr_name}\s*?\n((?>.*?\*/))}m
      $1
    else
      ''
    end
  end

  ##
  # Find the C code corresponding to a Ruby method

  def find_body(class_name, meth_name, meth_obj, body, quiet = false)
    case body
    when %r"((?>/\*.*?\*/\s*))(?:(?:static|SWIGINTERN)\s+)?(?:intern\s+)?VALUE\s+#{meth_name}
            \s*(\([^)]*\))([^;]|$)"xm
      comment, params = $1, $2
      body_text = $&

      remove_private_comments(comment) if comment

      # see if we can find the whole body

      re = Regexp.escape(body_text) + '[^(]*^\{.*?^\}'
      body_text = $& if /#{re}/m =~ body

      # The comment block may have been overridden with a 'Document-method'
      # block. This happens in the interpreter when multiple methods are
      # vectored through to the same C method but those methods are logically
      # distinct (for example Kernel.hash and Kernel.object_id share the same
      # implementation

      override_comment = find_override_comment(class_name, meth_obj.name)
      comment = override_comment if override_comment

      find_modifiers(comment, meth_obj) if comment

#        meth_obj.params = params
      meth_obj.start_collecting_tokens
      meth_obj.add_token(RDoc::RubyToken::Token.new(1,1).set_text(body_text))
      meth_obj.comment = mangle_comment(comment)
    when %r{((?>/\*.*?\*/\s*))^\s*\#\s*define\s+#{meth_name}\s+(\w+)}m
      comment = $1
      find_body(class_name, $2, meth_obj, body, true)
      find_modifiers(comment, meth_obj)
      meth_obj.comment = mangle_comment(comment) + meth_obj.comment
    when %r{^\s*\#\s*define\s+#{meth_name}\s+(\w+)}m
      unless find_body(class_name, $1, meth_obj, body, true)
        warn "No definition for #{meth_name}" unless @options.quiet
        return false
      end
    else

      # No body, but might still have an override comment
      comment = find_override_comment(class_name, meth_obj.name)

      if comment
        find_modifiers(comment, meth_obj)
        meth_obj.comment = mangle_comment(comment)
      else
        warn "No definition for #{meth_name}" unless @options.quiet
        return false
      end
    end
    true
  end

  def find_class(raw_name, name)
    unless @classes[raw_name]
      if raw_name =~ /^rb_m/
        container = @top_level.add_module RDoc::NormalModule, name
      else
        container = @top_level.add_class RDoc::NormalClass, name, nil
      end

      container.record_location @top_level
      @classes[raw_name] = container
    end
    @classes[raw_name]
  end

  ##
  # Look for class or module documentation above Init_+class_name+(void),
  # in a Document-class +class_name+ (or module) comment or above an
  # rb_define_class (or module).  If a comment is supplied above a matching
  # Init_ and a rb_define_class the Init_ comment is used.
  #
  #   /*
  #    * This is a comment for Foo
  #    */
  #   Init_Foo(void) {
  #       VALUE cFoo = rb_define_class("Foo", rb_cObject);
  #   }
  #
  #   /*
  #    * Document-class: Foo
  #    * This is a comment for Foo
  #    */
  #   Init_foo(void) {
  #       VALUE cFoo = rb_define_class("Foo", rb_cObject);
  #   }
  #
  #   /*
  #    * This is a comment for Foo
  #    */
  #   VALUE cFoo = rb_define_class("Foo", rb_cObject);

  def find_class_comment(class_name, class_meth)
    comment = nil
    if @content =~ %r{((?>/\*.*?\*/\s+))
                   (static\s+)?void\s+Init_#{class_name}\s*(?:_\(\s*)?\(\s*(?:void\s*)\)}xmi then
      comment = $1
    elsif @content =~ %r{Document-(?:class|module):\s#{class_name}\s*?(?:<\s+[:,\w]+)?\n((?>.*?\*/))}m
      comment = $1
    else
      if @content =~ /rb_define_(class|module)/m then
        class_name = class_name.split("::").last
        comments = []
        @content.split(/(\/\*.*?\*\/)\s*?\n/m).each_with_index do |chunk, index|
          comments[index] = chunk
          if chunk =~ /rb_define_(class|module).*?"(#{class_name})"/m then
            comment = comments[index-1]
            break
          end
        end
      end
    end
    class_meth.comment = mangle_comment(comment) if comment
  end

  ##
  # Finds a comment matching +type+ and +const_name+ either above the
  # comment or in the matching Document- section.

  def find_const_comment(type, const_name)
    if @content =~ %r{((?>^\s*/\*.*?\*/\s+))
                   rb_define_#{type}\((?:\s*(\w+),)?\s*"#{const_name}"\s*,.*?\)\s*;}xmi
      $1
    elsif @content =~ %r{Document-(?:const|global|variable):\s#{const_name}\s*?\n((?>.*?\*/))}m
      $1
    else
      ''
    end
  end

  ##
  # If the comment block contains a section that looks like:
  #
  #    call-seq:
  #        Array.new
  #        Array.new(10)
  #
  # use it for the parameters.

  def find_modifiers(comment, meth_obj)
    if comment.sub!(/:nodoc:\s*^\s*\*?\s*$/m, '') or
       comment.sub!(/\A\/\*\s*:nodoc:\s*\*\/\Z/, '')
      meth_obj.document_self = false
    end
    if comment.sub!(/call-seq:(.*?)^\s*\*?\s*$/m, '') or
       comment.sub!(/\A\/\*\s*call-seq:(.*?)\*\/\Z/, '')
      seq = $1
      seq.gsub!(/^\s*\*\s*/, '')
      meth_obj.call_seq = seq
    end
  end

  def find_override_comment(class_name, meth_name)
    name = Regexp.escape(meth_name)
    if @content =~ %r{Document-method:\s+#{class_name}(?:\.|::|#)#{name}\s*?\n((?>.*?\*/))}m then
      $1
    elsif @content =~ %r{Document-method:\s#{name}\s*?\n((?>.*?\*/))}m then
      $1
    end
  end

  def handle_attr(var_name, attr_name, reader, writer)
    rw = ''
    if reader
      #@stats.num_methods += 1
      rw << 'R'
    end
    if writer
      #@stats.num_methods += 1
      rw << 'W'
    end

    class_name = @known_classes[var_name]

    return unless class_name

    class_obj  = find_class(var_name, class_name)

    if class_obj
      comment = find_attr_comment(attr_name)
      unless comment.empty?
        comment = mangle_comment(comment)
      end
      att = RDoc::Attr.new '', attr_name, rw, comment
      class_obj.add_attribute(att)
    end
  end

  def handle_class_module(var_name, class_mod, class_name, parent, in_module)
    parent_name = @known_classes[parent] || parent

    if in_module
      enclosure = @classes[in_module] || @@enclosure_classes[in_module]
      unless enclosure
        if enclosure = @known_classes[in_module]
          handle_class_module(in_module, (/^rb_m/ =~ in_module ? "module" : "class"),
                              enclosure, nil, nil)
          enclosure = @classes[in_module]
        end
      end
      unless enclosure
        warn("Enclosing class/module '#{in_module}' for " +
              "#{class_mod} #{class_name} not known")
        return
      end
    else
      enclosure = @top_level
    end

    if class_mod == "class" then
      full_name = enclosure.full_name.to_s + "::#{class_name}"
      if @content =~ %r{Document-class:\s+#{full_name}\s*<\s+([:,\w]+)} then
        parent_name = $1
      end
      cm = enclosure.add_class RDoc::NormalClass, class_name, parent_name
      @stats.add_class cm
    else
      cm = enclosure.add_module RDoc::NormalModule, class_name
      @stats.add_module cm
    end

    cm.record_location(enclosure.toplevel)

    find_class_comment(cm.full_name, cm)
    @classes[var_name] = cm
    @@enclosure_classes[var_name] = cm
    @known_classes[var_name] = cm.full_name
  end

  ##
  # Adds constant comments.  By providing some_value: at the start ofthe
  # comment you can override the C value of the comment to give a friendly
  # definition.
  #
  #   /* 300: The perfect score in bowling */
  #   rb_define_const(cFoo, "PERFECT", INT2FIX(300);
  #
  # Will override +INT2FIX(300)+ with the value +300+ in the output RDoc.
  # Values may include quotes and escaped colons (\:).

  def handle_constants(type, var_name, const_name, definition)
    #@stats.num_constants += 1
    class_name = @known_classes[var_name]

    return unless class_name

    class_obj  = find_class(var_name, class_name)

    unless class_obj
      warn("Enclosing class/module '#{const_name}' for not known")
      return
    end

    comment = find_const_comment(type, const_name)

    # In the case of rb_define_const, the definition and comment are in
    # "/* definition: comment */" form.  The literal ':' and '\' characters
    # can be escaped with a backslash.
    if type.downcase == 'const' then
       elements = mangle_comment(comment).split(':')
       if elements.nil? or elements.empty? then
          con = RDoc::Constant.new(const_name, definition,
                                   mangle_comment(comment))
       else
          new_definition = elements[0..-2].join(':')
          if new_definition.empty? then # Default to literal C definition
             new_definition = definition
          else
             new_definition.gsub!("\:", ":")
             new_definition.gsub!("\\", '\\')
          end
          new_definition.sub!(/\A(\s+)/, '')
          new_comment = $1.nil? ? elements.last : "#{$1}#{elements.last.lstrip}"
          con = RDoc::Constant.new(const_name, new_definition,
                                   mangle_comment(new_comment))
       end
    else
       con = RDoc::Constant.new const_name, definition, mangle_comment(comment)
    end

    class_obj.add_constant(con)
  end

  ##
  # Removes #ifdefs that would otherwise confuse us

  def handle_ifdefs_in(body)
    body.gsub(/^#ifdef HAVE_PROTOTYPES.*?#else.*?\n(.*?)#endif.*?\n/m, '\1')
  end

  def handle_method(type, var_name, meth_name, meth_body, param_count,
                    source_file = nil)
    class_name = @known_classes[var_name]

    return unless class_name

    class_obj = find_class var_name, class_name

    if class_obj then
      if meth_name == "initialize" then
        meth_name = "new"
        type = "singleton_method"
      end

      meth_obj = RDoc::AnyMethod.new '', meth_name
      meth_obj.singleton = %w[singleton_method module_function].include? type

      p_count = (Integer(param_count) rescue -1)

      if p_count < 0
        meth_obj.params = "(...)"
      elsif p_count == 0
        meth_obj.params = "()"
      else
        meth_obj.params = "(" + (1..p_count).map{|i| "p#{i}"}.join(", ") + ")"
      end

      if source_file then
        file_name = File.join(@file_dir, source_file)
        body = (@@known_bodies[source_file] ||= File.read(file_name))
      else
        body = @content
      end

      if find_body(class_name, meth_body, meth_obj, body) and meth_obj.document_self then
        class_obj.add_method meth_obj
        @stats.add_method meth_obj
      end
    end
  end

  def handle_tab_width(body)
    if /\t/ =~ body
      tab_width = @options.tab_width
      body.split(/\n/).map do |line|
        1 while line.gsub!(/\t+/) { ' ' * (tab_width*$&.length - $`.length % tab_width)}  && $~ #`
        line
      end .join("\n")
    else
      body
    end
  end

  ##
  # Remove the /*'s and leading asterisks from C comments

  def mangle_comment(comment)
    comment.sub!(%r{/\*+}) { " " * $&.length }
    comment.sub!(%r{\*+/}) { " " * $&.length }
    comment.gsub!(/^[ \t]*\*/m) { " " * $&.length }
    comment
  end

  ##
  # Removes lines that are commented out that might otherwise get picked up
  # when scanning for classes and methods

  def remove_commented_out_lines
    @content.gsub!(%r{//.*rb_define_}, '//')
  end

  def remove_private_comments(comment)
     comment.gsub!(/\/?\*--\n(.*?)\/?\*\+\+/m, '')
     comment.sub!(/\/?\*--\n.*/m, '')
  end

  ##
  # Extract the classes/modules and methods from a C file and return the
  # corresponding top-level object

  def scan
    remove_commented_out_lines
    do_classes
    do_constants
    do_methods
    do_includes
    do_aliases
    @top_level
  end

  def warn(msg)
    $stderr.puts
    $stderr.puts msg
    $stderr.flush
  end

end