(12) United States Patent
`Vaidyanathan et al.
`
`I lllll llllllll Ill lllll lllll lllll lllll lllll 111111111111111111111111111111111
`US006502233Bl
`US 6,502,233 Bl
`Dec. 31, 2002
`
`(10) Patent No.:
`(45) Date of Patent:
`
`(54) AUTOMATED HELP SYSTEM FOR
`REFERENCE INFORMATION
`
`(75)
`
`Inventors: Shankar Vaidyanathan, Bellevue;
`Philip Lucido, Redmond; Sundeep
`Bhatia, Bellevue, all of WA (US)
`
`(73) Assignee: Microsoft Corporation, Redmond, WA
`(US)
`
`( *) Notice:
`
`Subject to any disclaimer, the term of this
`patent is extended or adjusted under 35
`U.S.C. 154(b) by 0 days.
`
`(21) Appl. No.: 09/191,757
`
`(22) Filed:
`
`Nov. 13, 1998
`
`(51)
`Int. Cl.7 .................................................. G06F 9/44
`(52) U.S. Cl. ........................ 717/101; 717/106; 717/163
`(58) Field of Search .......................... 717/1, 2, 11, 106,
`717/163, 164, 100, 101, 110; 345/326,
`327; 709/300, 303, 305; 707/500, 513,
`516, 526, 530
`
`(56)
`
`References Cited
`
`U.S. PATENT DOCUMENTS
`4,809,170 A * 2/1989 Leblang et al. ............. 717/122
`5,430,836 A * 7/1995 Wolf et al.
`................. 345/335
`5,627,958 A * 5/1997 Potts et al.
`................. 345/336
`5,644,737 A * 7/1997 Tuniman et al. ............ 345/352
`5,694,559 A * 12/1997 Hobson et al.
`............. 411/120
`5,781,720 A * 7/1998 Parker et al.
`................. 714/38
`5,825,355 A * 10/1998 Palmer et al.
`.............. 345/336
`5,859,638 A * 1/1999 Coleman et al. ............ 345/341
`5,872,974 A * 2/1999 Mezick ....................... 717/109
`5,911,059 A * 6/1999 Profit, Jr. ..................... 703/23
`
`6,053,951 A * 4/2000 McDonald et al.
`............ 717/1
`6,071,317 A * 6/2000 Nagel ............................ 717/4
`6,205,579 Bl * 3/2001 Southgate ................... 717/173
`6,275,976 Bl * 8/2001 Scandura .................... 717/120
`
`OTHER PUBLICATIONS
`
`Franke et al, "Authoring a hypertext help manual", ACM pp
`238-245, 1995.*
`Paterno, "Automatic genertaion of task oriented help", UIST
`ACM pp 181-187, Nov. 1995.*
`Sukaviriya et al, "Automatic generation of textual, audio and
`animated help in UIDE: the user interface design environ(cid:173)
`ment", AVI ACM pp 44-52, Feb. 1994.*
`Szekely et al. "Automatic generation of help from interface
`design module", ACM CHI, pp 225-231, Jun. 1994.*
`Olsson, "Population management for automatic design of
`algorithms through evolution", IEEE, pp 592-597, Sep.
`1998.*
`Franke et al, "Authoring a hypertext unix help manual",
`ACM pp 238-245, 1995.*
`Comeau et al, A window based help, tutorial and documen(cid:173)
`tation system, ACM, pp 71-81, Jan. 1993.*
`
`* cited by examiner
`
`Primary Examiner-Anil Khatri
`
`(57)
`
`ABSTRACT
`
`Automatic parameter help is disclosed. In one embodiment,
`the system comprises an editor to provide for developing
`source code for a computer program, where the source code
`includes an identifier; and an automatic help module
`invoked upon a predetermined event by the editor. The
`automatic help module is operative to display reference
`information associated with the identifier.
`
`39 Claims, 9 Drawing Sheets
`
`Automatic
`
`__. Help Module -
`220
`'
`
`200
`
`µ
`
`Database 225
`
`Editor 205
`
`Source
`Code 210
`
`~
`
`,
`Parser 215 -
`
`-+-
`--
`
`AXR-1004-Page 1 of 22
`
`

`
`Ii-"
`~
`~
`~
`'N
`N
`Q
`'&.
`O'I
`rJ"J.
`
`e
`
`\C
`
`'"""' 0 ....,,
`~ .....
`rF.J. =(cid:173)~
`
`N c c
`'"""' ~
`~
`ri
`~
`~
`
`N
`
`~ = ......
`~ ......
`~
`•
`\JJ.
`d •
`
`36
`
`PROGRAMS
`APPLICATION
`
`FIG. 1
`
`.tt
`COMPUTER
`
`REMOTE
`
`52
`
`4
`
`Wide Area Network
`
`Keyboard 40
`
`42
`
`Mouse
`
`DATA .as.
`PROGRAM
`
`31
`
`--...
`
`MODS . .ll
`
`PROGRAM
`
`OTHER
`
`~
`
`PROGRAMS
`
`»
`
`SYSTEM
`
`OPERATING I APPLICATION
`
`__ .. ---·
`
`L ---~-~-=-=-:,_-;.-/:: --------Co._,_~~-~-=-::. ----------
`
`1
`
`Network
`1
`1 Local Area
`I
`
`ll
`
`Interface
`Network
`
`.§
`
`Interface
`Serial Port
`
`.li.
`Interface
`
`Drive
`Optical
`
`?R
`.ll
`Interface
`
`Drive
`
`32
`Interface
`
`Hard Disk
`
`Drive
`
`I L___-~~
`
`.ll _
`
`I Program
`
`Data
`
`.
`
`Modules ll
`
`Other Program
`
`.
`
`_
`
`·I o·· I
`
`:
`1
`I
`I
`I
`I
`1
`1
`
`~-
`Video
`
`.
`
`L__-~~-=-=~
`
`21
`
`Processing
`
`Unit
`
`!)O Monitor 47
`
`I -
`
`I
`
`I
`
`I
`
`I
`I
`
`:-s~~t~~ -M-e~~~---_2_2_ --------------------=-~~ ------------:
`
`1 I ___ ~I~~--~ I
`
`Programs 1§.
`Application
`
`S stem M
`~~~
`
`,n
`
`(RAM)
`
`I
`I ---------
`
`(ROM) .li
`
`AXR-1004-Page 2 of 22
`
`

`
`U.S. Patent
`
`Dec. 31, 2002
`
`Sheet 2 of 9
`
`US 6,502,233 Bl
`
`200
`J
`
`-~
`
`
`
`--
`__.. Help Module
`
`Automatic
`
`220
`
`h
`
`, '
`
`Database 225
`
`Editor 205
`
`Source
`Code 210
`
`J l
`
`1 ,
`
`~ Parser 215
`--
`
`~
`
`~
`
`FIG. 2
`
`AXR-1004-Page 3 of 22
`
`

`
`U.S. Patent
`
`Dec. 31, 2002
`
`Sheet 3 of 9
`
`US 6,502,233 Bl
`
`class Foo {
`public:
`
`int x;
`int y;
`int z;
`
`II X coordinate of object
`II Y coordinate of object~355
`II Z coordinate of object~360
`/'\..-365
`II getVolume calculates a volume for the object
`double getVolume(double length, double width, float height) const;
`
`350
`
`FIG. 3(a)
`
`2370
`
`AXR-1004-Page 4 of 22
`
`

`
`U.S. Patent
`
`Dec. 31, 2002
`
`Sheet 4 of 9
`
`US 6,502,233 Bl
`
`302
`
`300
`
`Foo *m_pfoo;
`
`304
`
`Source statement A;
`Source statement B;
`Source statement C;
`
`m_pfoo->getVolume( > .. d;...o-ub-le_F_o_o_: :g-e-tV-o-lu-m-e(-do_u_b_le-1-en-g-th-, -do_u_b-le-w-id-th-, fl_o_a_t h-e-ig-ht-) -co-n-st-
`
`306
`
`308
`
`FIG. 3(b)
`
`AXR-1004-Page 5 of 22
`
`

`
`U.S. Patent
`
`Dec. 31, 2002
`
`Sheet 5 of 9
`
`US 6,502,233 Bl
`
`302
`
`316
`
`Foo *m_pfoo;
`
`Source statement A;
`Source statement B;
`Source statement C;
`
`m_>oo->.,_x _____ _.
`
`322
`
`.,.Y ____ __.
`z
`getVolume
`
`304
`
`374
`
`II getVolume calculates a volume for the object
`
`324
`
`330
`
`FIG. 3(c)
`
`AXR-1004-Page 6 of 22
`
`

`
`U.S. Patent
`
`Dec. 31, 2002
`
`Sheet 6 of 9
`
`US 6,502,233 Bl
`
`Foo *m_pfoo;
`
`Source statement A;
`Source statement B;
`Source statement C;
`
`304
`
`Ycoordinate of object
`
`<
`m _~f 00-> f -xy - - - - t - - - - - - - - - - - ,
`
`322
`
`z
`f-----------1
`getVolume
`
`318
`
`302
`
`326
`
`324
`
`FIG. 3(d)
`
`AXR-1004-Page 7 of 22
`
`

`
`U.S. Patent
`
`Dec. 31, 2002
`
`Sheet 7 of 9
`
`US 6,502,233 Bl
`
`too *m_pfoo;
`
`-
`
`Source statement A;
`Source statement B;
`Source statement C;
`-
`
`m 2fOO->Z
`I int Foo::z
`
`323
`
`"'--304
`
`~340
`
`~ ---332
`
`r.._.,
`302
`
`FIG. 3(e)
`
`AXR-1004-Page 8 of 22
`
`

`
`U.S. Patent
`
`Dec. 31, 2002
`
`Sheet 8 of 9
`
`US 6,502,233 Bl
`
`Foo *m_pfoo;
`
`-
`
`Source statement A; ~304
`Source statement B;
`Source statement C;
`-
`m_pfoo->x,___ ________ ~r- 314
`!
`'--"""
`
`< I X coordinate of object
`
`312
`
`~--320
`
`f'\...,302
`
`FIG. 3(f)
`
`AXR-1004-Page 9 of 22
`
`

`
`U.S. Patent
`
`Dec. 31, 2002
`
`Sheet 9 of 9
`
`US 6,502,233 Bl
`
`Develop Code
`
`400
`
`Detect Event
`
`410
`
`Parse Current Code
`
`412
`
`Search for Information
`on Identifier
`
`415
`
`420
`
`Info. Available? >----No-~
`
`Yes
`
`~405
`
`Provide Data
`
`425
`
`End
`
`L------------------------------
`
`FIG. 4
`
`AXR-1004-Page 10 of 22
`
`

`
`US 6,502,233 Bl
`
`1
`AUTOMATED HELP SYSTEM FOR
`REFERENCE INFORMATION
`
`RELATED APPLICATIONS
`
`This application is related to the following commonly
`assigned co-pending applications, all filed on Nov. 13, 1998:
`"Dynamic Parsing"-U.S. patent application Ser. No.
`09/191,499,
`"Automatic Statement Completion"-U.S. patent appli-
`cation Ser. No. 09/191,781, and
`"Indexing and Searching Across Multiple Sorted
`Arrays"-U.S. patent application Ser. No. 09/192,057.
`
`COPYRIGHT NOTICE/PERMISSION
`
`10
`
`2
`One manner by which compilers and interpreters have
`become somewhat easier to use is through the use of the
`Integrated Development Environment (IDE). These envi(cid:173)
`ronments typically support some kind of on-line help
`5 mechanism allowing a developer to refer to on-line docu(cid:173)
`mentation describing varying function definitions, thereby
`providing an improvement over printed manuals and text
`searching across multiple source files. Also, these environ-
`ments typically have browsers capable of opening multiple
`source files, allowing a developer to refer to the source file
`defining a particular function or class attribute while editing
`another source file. In addition, for object oriented
`languages, the IDE may also provide a browser allowing the
`developer access to the class hierarchy enabling a developer
`15 to browse a class definition.
`While on-line help and browsers are an improvement to
`printed manuals and text searching, several problems
`remain. First, in order to look up the definition of a function
`or member attribute, the developer must locate the source
`file containing the function or attribute definition, consult
`the on-line help file, or locate the class name in the class
`hierarchy browser.
`Second, the user must locate the function or attribute
`definition in the file, which typically involves either scroll-
`25 ing through the file, using a text search capability to search
`through the file, or using the browser to locate the function
`or attribute definition in the file.
`Finally, once the function or attribute definition has been
`located, the user must typically alternate back and forth
`30 between the window containing the definition of the func(cid:173)
`tion or attribute (either in a file window or a class hierarchy
`window) and the window containing the source code cur(cid:173)
`rently being edited.
`
`A portion of the disclosure of this patent document
`contains material which is subject to copyright protection.
`The copyright owner has no objection to the facsimile
`reproduction by anyone of the patent document or the patent
`disclosure as it appears in the Patent and Trademark Office 20
`patent file or records, but otherwise reserves all copyright
`rights whatsoever. The following notice applies to the soft(cid:173)
`ware and data as described below and in the drawing hereto:
`Copyright © 1998, Microsoft Corporation, All Rights
`Reserved.
`
`FIELD
`This invention relates generally to software development
`environments, and more particularly to automatically pro(cid:173)
`viding help information.
`
`BACKGROUND
`Over time computer programs and the software program(cid:173)
`ming languages used to develop them have become more
`complex. Computer programs are typically composed of 35
`many different source code files and programming libraries.
`These libraries include system libraries, networking libraries
`and utility libraries comprising many different functions or
`methods. In addition, object oriented languages have imple(cid:173)
`mented a concept referred to as function overloading. Fune- 40
`ti on overloading occurs when multiple functions (or
`methods) within a class hierarchy share the same name (or
`identifier), but have differing numbers of parameters or
`differing parameter types. Because of the proliferation of
`libraries and classes, the number of functions available to a 45
`software developer has steadily risen. This makes it very
`difficult if not impossible for a software developer to remem(cid:173)
`ber the calling sequence for a particular function.
`In addition to function definitions, classes in object ori(cid:173)
`ented languages typically have member attributes such as 50
`functions and properties. These attributes are used to define
`varying aspects of the class. Often the source code defining
`these attributes has comments associated with the attributes
`indicating how they are used. The number of these attributes
`in any single class can grow quite large, and combined with 55
`the fact that attributes can be inherited from parent classes
`can make it difficult for a software developer to remember
`the purpose and use for a particular attribute.
`A further factor complicating the software development
`effort is the fact that it is often the case that a software 60
`module will define a large number of identifiers. These
`identifiers comprise typedefs, variables, macros, parameters,
`namespaces, templates, attributes, etc. and must each have a
`type, declaration and/or definition specified. It is often
`difficult for a developer to remember the type and identifier 65
`for these entities. In addition this information is context
`dependent.
`
`SUMMARY
`The above-identified problems, shortcomings and disad(cid:173)
`vantages with the prior art, as well as other problems,
`shortcoming and disadvantages, are solved by the present
`invention, which will be understood by reading and studying
`the specification and the drawings. In one embodiment, the
`system includes an editor to provide for developing source
`code for a computer program. The source code includes
`statements containing identifiers. In addition, the editor,
`upon detecting an event from a pre-determined set of events,
`invokes an automatic help module. The automatic help
`module displays reference information associated with the
`identifier.
`Thus one aspect of the invention is that while a program(cid:173)
`mer is developing or writing source code for a program, the
`automatic help module is invoked upon the occurrence of a
`predetermined event. The event can be the positioning of a
`cursor over an identifier followed by a clicking a mouse
`button, hovering the mouse cursor over an identifier, select(cid:173)
`ing a menu or icon after highlighting the identifier, or the
`event can be the entry of an identifier into the source code.
`The automatic help module then displays reference infor(cid:173)
`mation regarding the identifier. In one embodiment of the
`invention, the reference information is a list of parameters
`for the function with the associated data type for each
`parameter. The first required parameter in the displayed list
`is highlighted. As the developer enters further function
`parameters (if any) in the source code, the next required
`parameter is highlighted. In addition, in one embodiment of
`the invention, as the user provides more data, the list of
`overloaded functions and their associated parameter sets can
`be pruned to remove those items that are incompatible with
`what the user has already entered.
`
`AXR-1004-Page 11 of 22
`
`

`
`US 6,502,233 Bl
`
`5
`
`3
`In an alternative embodiment of the invention, the refer(cid:173)
`ence information is the data type of the identifier.
`In a further alternative embodiment, the source code is
`searched for comments associated with an identifier. If any
`comments are found, the comments are displayed, thereby
`providing potentially useful information to the developer.
`Thus embodiments of the invention have advantages not
`found in prior systems. The developer is able to view
`relevant reference information regarding functions and
`attributes without having to consult on-line help directories,
`source code files containing identifier definitions, paper
`documentation, or other potential sources of identifier infor(cid:173)
`mation. This saves the developer time and does not interrupt
`the developer's train of thought. In this manner, develop(cid:173)
`ment of computer programs is made easier and more pro- 15
`ductive as compared to previous systems.
`The invention includes systems, methods, computers, and
`computer-readable media of varying scope. Besides the
`embodiments, advantages and aspects of the invention
`described here, the invention also includes other
`embodiments, advantages and aspects, as will become
`apparent by reading and studying the drawings and the
`following description.
`
`BRIEF DESCRIPTION OF THE DRAWINGS
`
`FIG. 1 shows a diagram of the hardware and operating
`environment in conjunction with which embodiments of the
`invention may be practiced;
`FIG. 2 shows a block diagram of a system according to
`one embodiment of the invention;
`FIG. 3(a) shows a sample C++ class definition;
`FIGS. 3(b), 3(c), 3(d), 3(e) and 3(j) are illustrations of
`representative screen shots of an IDE where the automatic
`help module has been invoked; and,
`FIG. 4 shows a flowchart illustrating a method according
`to one embodiment of the invention.
`
`DETAILED DESCRIPTION
`
`In the following detailed description of exemplary
`embodiments of the invention, reference is made to the
`accompanying drawings which form a part hereof, and in
`which is shown by way of illustration specific exemplary
`embodiments in which the invention may be practiced.
`These embodiments are described in sufficient detail to
`enable those skilled in the art to practice the invention, and
`it is to be understood that other embodiments may be utilized
`and that logical, mechanical, electrical and other changes
`may be made without departing from the spirit or scope of
`the present invention. The following detailed description is,
`therefore, not to be taken in a limiting sense, and the scope
`of the present invention is defined only by the appended
`claims.
`The detailed description is divided into four sections. In
`the first section, the hardware and the operating environment
`in conjunction with which embodiments of the invention
`may be practiced are described. In the second section, a
`system of one embodiment of the invention is presented. In
`the third section, a method, in accordance with an embodi(cid:173)
`ment of the invention, is provided. Finally, in the fourth
`section, a conclusion of the detailed description is provided.
`
`Hardware and Operating Environment
`
`Referring to FIG. 1, a diagram of the hardware and
`operating environment in conjunction with which embodi-
`
`4
`ments of the invention may be practiced is shown. The
`description of FIG. 1 is intended to provide a brief, general
`description of suitable computer hardware and a suitable
`computing environment in conjunction with which the
`invention may be implemented. Although not required, the
`invention is described in the general context of computer(cid:173)
`executable instructions, such as program modules, being
`executed by a computer, such as a personal computer.
`Generally, program modules include routines, programs,
`10 objects, components, data structures, etc., that perform par(cid:173)
`ticular tasks or implement particular abstract data types.
`Moreover, those skilled in the art will appreciate that the
`invention may be practiced with other computer system
`configurations, including hand-held devices, multiprocessor
`systems, microprocessor-based or programmable consumer
`electronics, network PCS, minicomputers, mainframe
`computers, and the like. The invention may also be practiced
`in distributed computing environments where tasks are
`performed by remote processing devices that are linked
`20 through a communications network. In a distributed com(cid:173)
`puting environment, program modules may be located in
`both local and remote memory storage devices.
`The exemplary hardware and operating environment of
`FIG. 1 for implementing the invention includes a general
`25 purpose computing device in the form of a computer 20,
`including a processing unit 21, a system memory 22, and a
`system bus 23 that operatively couples various system
`components include the system memory to the processing
`unit 21. There may be only one or there may be more than
`30 one processing unit 21, such that the processor of computer
`20 comprises a single central-processing unit (CPU), or a
`plurality of processing units, commonly referred to as a
`parallel processing environment. The computer 20 may be a
`conventional computer, a distributed computer, or any other
`35 type of computer; the invention is not so limited.
`The system bus 23 may be any of several types of bus
`structures including a memory bus or memory controller, a
`peripheral bus, and a local bus using any of a variety of bus
`40 architectures. The system memory may also be referred to as
`simply the memory, and includes read only memory (ROM)
`24 and random access memory (RAM) 25. A basic input/
`output system (BIOS) 26, containing the basic routines that
`help to transfer information between elements within the
`45 computer 20, such as during start-up, is stored in ROM 24.
`The computer 20 further includes a hard disk drive 27 for
`reading from and writing to a hard disk, not shown, a
`magnetic disk drive 28 for reading from or writing to a
`removable magnetic disk 29, and an optical disk drive 30 for
`50 reading from or writing to a removable optical disk 31 such
`as a CD ROM or other optical media.
`The hard disk drive 27, magnetic disk drive 28, and
`optical disk drive 30 are connected to the system bus 23 by
`a hard disk drive interface 32, a magnetic disk drive inter(cid:173)
`face 33, and an optical disk drive interface 34, respectively.
`The drives and their associated computer-readable media
`provide nonvolatile storage of computer-readable
`instructions, data structures, program modules and other
`data for the computer 20. It should be appreciated by those
`skilled in the art that any type of computer-readable media
`which can store data that is accessible by a computer, such
`as magnetic cassettes, flash memory cards, digital video
`disks, Bernoulli cartridges, random access memories
`(RAMs), read only memories (ROMs), and the like, may be
`65 used in the exemplary operating environment.
`A number of program modules may be stored on the hard
`disk, magnetic disk 29, optical disk 31, ROM 24, or RAM
`
`55
`
`60
`
`AXR-1004-Page 12 of 22
`
`

`
`US 6,502,233 Bl
`
`5
`25, including an operating system 35, one or more applica(cid:173)
`tion programs 36, other program modules 37, and program
`data 38. A user may enter commands and information into
`the personal computer 20 through input devices such as a
`keyboard 40 and pointing device 42. Other input devices 5
`(not shown) may include a microphone, joystick, game pad,
`satellite dish, scanner, or the like. These and other input
`devices are often connected to the processing unit 21
`through a serial port interface 46 that is coupled to the
`system bus, but may be connected by other interfaces, such 10
`as a parallel port, game port, or a universal serial bus (USE).
`A monitor 47 or other type of display device is also
`connected to the system bus 23 via an interface, such as a
`video adapter 48. In addition to the monitor, computers
`typically include other peripheral output devices (not 15
`shown), such as speakers and printers.
`The computer 20 may operate in a networked environ(cid:173)
`ment using logical connections to one or more remote
`computers, such as remote computer 49. These logical
`connections are achieved by a communication device
`coupled to or a part of the computer 20; the invention is not
`limited to a particular type of communications device. The
`remote computer 49 may be another computer, a server, a
`router, a network PC, a client, a peer device or other
`common network node, and typically includes many or all of 25
`the elements described above relative to the computer 20,
`although only a memory storage device 50 has been illus(cid:173)
`trated in FIG. 1. The logical connections depicted in FIG. 1
`include a local-area network (LAN) 51 and a wide-area
`network (WAN) 52. Such networking environments are 30
`commonplace in office networks, enterprise-wide computer
`networks, intranets and the Internet, which are all types of
`networks.
`When used in a LAN-networking environment, the com(cid:173)
`puter 20 is connected to the local network 51 through a
`network interface or adapter 53, which is one type of
`communications device. When used in a WAN-networking
`environment, the computer 20 typically includes a modem
`54, a type of communications device, or any other type of
`communications device for establishing communications
`over the wide area network 52, such as the Internet. The
`modem 54, which may be internal or external, is connected
`to the system bus 23 via the serial port interface 46. In a
`networked environment, program modules depicted relative
`to the personal computer 20, or portions thereof, may be
`stored in the remote memory storage device. It is appreciated
`that the network connections shown are exemplary and other
`means of and communications devices for establishing a
`communications link between the computers may be used.
`The hardware and operating environment in conjunction
`with which embodiments of the invention may be practiced
`has been described. The computer in conjunction with which
`embodiments of the invention may be practiced may be a
`conventional computer, a distributed computer, or any other
`type of computer; the invention is not so limited. Such a
`computer typically includes one or more processing units as
`its processor, and a computer-readable medium such as a
`memory. The computer may also include a communications
`device such as a network adapter or a modem, so that it is
`able to communicatively couple other computers.
`
`40
`
`6
`to an embodiment of the invention includes an Integrated
`Development Environment (IDE) 200. As shown, the IDE
`200 includes an editor 205, parser 215, automatic help
`module 220 and database 225. Those of ordinary skill within
`the art will appreciate that the IDE 200 also may include
`other components, not shown in FIG. 2; only those parts
`necessary to describe the invention in an enabling manner
`are provided. The parser 215 may be a parser for any type
`of programming language; the invention is not so limited.
`For example, the parser 215 can in different embodiments
`parse the C, C++, Pascal, Visual BASIC, or Java program-
`ming languages etc., all of which are known in the art. In
`addition, IDE 200 may include what is known in the art as
`an interpreter.
`The parser 215 converts source code 210 into executable
`code (not shown in FIG. 2). The source code 210 is a text
`description of a computer program, as written in a given
`programming language by or for one or more computer
`programmers. Typically and as is known in the art, the
`20 source code comprises a series of statements defining the
`data structures and the actions the computer is to perform
`using the data structures. These statements are composed of
`various programming language tokens, which are combined
`to form declarations and definitions that describe the entities
`that make up the computer program. Identifiers are used to
`identify particular entities in the program, such as function
`names, variable names, class names, macro names and
`template names. Those of ordinary skill in the art will
`recognize that various entities and identifier mechanisms are
`used in various programming languages.
`The executable code is that which is produced by the IDE
`200, so that the computer program can actually be run on a
`computer (for example, a computer as has been described in
`the preceding section of the detailed description). The parser
`35 215 operates to parse the source code 210 according to the
`parsing rules applicable to a particular programming lan(cid:173)
`guage. In one embodiment of the invention, the parser 215
`stores and retrieves information to and from database 225.
`The editor 205 of the IDE 200 provides for the developing
`(writing) of the source code 210 of a computer program.
`Automatic help module 220 is invoked by editor 205 upon
`the occurrence of an event and employs the method
`described below with reference to FIG. 4 to automatically
`45 provide reference information on an identifier in the source
`code.
`Database 225 is typically a file comprising a database that,
`in one embodiment of the invention, is used by the parser to
`store information including, but not limited to class
`50 definitions, member data types, member function names and
`their associated parameters. In addition, reference informa(cid:173)
`tion such as source file names and line numbers where an
`entity is defined or referenced is stored in database 225.
`Database 225 typically includes information not only from
`55 source code 210, but also includes information from other
`sources including system header files and files from class
`libraries including Microsoft Foundation Class (MFC)
`header files and ActiveX Template Libraries (ATL), all of
`which are known in the art. The database 225 stores an
`60 indicator as to which of the above-mentioned sources was
`used to populate the particular database record.
`In one embodiment of the invention, database 225 is
`referred to as an NCB (No Compile Browse) file, and is
`populated and maintained by the parser module 215. In this
`65 embodiment, the parser module 215 dynamically updates
`the database 225 as the source code is modified or added to
`by the user. The creation and maintenance of the database
`
`System
`
`In this section of the detailed description, a description of
`a computerized system according to an embodiment of the
`invention is provided. The description is provided by refer(cid:173)
`ence to FIG. 2. Referring now to FIG. 2, a system according
`
`AXR-1004-Page 13 of 22
`
`

`
`US 6,502,233 Bl
`
`7
`225 by parser module 215 is more fully described in
`coassigned, cofiled and copending application entitled
`"Dynamic Parsing" which has been previously incorporated
`by reference.
`In an alternative embodiment of the invention, database
`225, while appearing as one database to the user, is actually
`comprised of multiple stores or databases. In this
`embodiment, a first database is dynamically updated by the
`parser, as described above. In addition to the first dynami(cid:173)
`cally updated database, one or more pre-created databases
`exist. The pre-created databases contain information that
`seldom changes, such as operating system declarations and
`header files, Microsoft Foundation Class definitions and
`header files, and the ActiveX Template Library referred to
`above. Those of ordinary skill in the art will recognize that
`other class definitions and header files could be included in
`the pre-created database. It is desirable to provide such a
`pre-created database because of the large amount of infor(cid:173)
`mation that is provided by the class definitions and header
`files. This information seldom changes, and therefore does
`not need to be re-parsed and stored in the dynamically
`updated database. This allows the parser to dynamically
`parse the user developed code, which does change
`frequently, in an acceptable amount of time.
`Thus, in accordance with one embodiment of the
`invention, the system of FIG. 2 operates as follows. A
`developer drafts the source code 210 using the editor 205. As
`the developer is writing the source code 210, editor 205
`detects a predetermined event and invokes automatic help
`module 220. Automatic help module 220 then queries data(cid:173)
`base 225 and uses the information found therein to display
`a tooltip box providing reference information on an identi(cid:173)
`fier in the source code. In one embodiment of the invention,
`the predetermined event occurs when a user enters a par(cid:173)
`ticular token or type of token. Examples of tokens include
`identifier names, function name, class names, macro names,
`global and local variable names, and operators.
`In an alternative embodiment, the automatic help module
`220 is invoked when the user positions a cursor over an
`identifier. The module can be invoked either by pressing a
`button, or by allowing the mouse cursor to "hover" over the
`token.
`In a further alternative embodiment of the invention,
`automatic help module 220 is invoked when the user high(cid:173)
`lights a token and presses a mouse button or hot-key. A
`hot-key is known in the art, and typically comprises a
`function key or sequence of predefined keys that have
`special meaning to an application.
`The invention is not limited to the mechanisms described 50
`above to invoke the automatic help module, and those of
`ordinary skill in the art will appreciate that other mecha(cid:173)
`nisms can be utilized and are within the scope of the
`invention. Such mechanisms include menu selection and
`icon selection.
`FIG. 3(a) presents a sample class definition and FIGS.
`3(b )-3({) illustrate representative screen shots of editing
`sessions using the class definition. FIGS. 3(a)-3(j) are
`discussed in the context of the C++ programming language,
`however the invention is not so limited. The invention is
`adaptable to any programming language. Referring now to
`FIG. 3(a), a C++ class definition 350 is presented for the
`class named "Foo". Sample class Foo has three member
`attributes, an x coordinate location attribute 355, a y coor(cid:173)
`dinate location attribute 360, and a z coordinate location
`attribute 365. The three attributes have comments associated
`with them indicating their intended use. In addition, class
`
`8
`Foo has a member function getVolume 370 which accepts
`three parameters. The declaration for get Volume is preceded
`by a code comment indicating the method's purpose. The
`class definition for class Foo may be contained in the source
`5 code 210 file currently being edited, or more commonly, it
`may be contained in any of a number of files comprising th