text:
|Publication number
|Publication type
|Application number
|Publication date
|Jun 5, 1990
|Filing date
|Nov 9, 1988
|Priority date
|Nov 9, 1988
|Fee status
|Publication number
|Norton R. Greenfeld
|Original Assignee
|Greenfeld Norton R
|Export Citation
|BiBTeX, EndNote, RefMan
|Patent Citations (6), Non-Patent Citations (6), Referenced by (191), Classifications (14), Legal Events (5)
|External Links: USPTO, USPTO Assignment, Espacenet
As software systems are developed and maintained there is a strong tendency to write new programs to accomplish tasks rather than re-use or modify software already existing. This makes the general complexity of software systems increase with concommitment increase in size, maintenance effort and in conceptual effort needed to understand and control future development.
These tendencies are controlled in the present art with diagrammatic methodologies for visualizing the system at a variety of conceptual levels, with design decisions that limit functionality and future expansion possibilities and with management discipline to ensure manual review of changes proposed.
Missing from the present art are tools and methods for examining existing source code to find opportunities for simplification, generalization, consolidation or any other automated or semi-automated support means for helping software designers and developers reconceptualize the code into a more coherent and manageable form. Source code therefore evolves in the direction of increasing size and complexity rather than increasing coherency and generalization. The overall costs of such trends are enormous.
Source code analysis also provides powerful tools for the system analyst working on maintaining or enhancing an existing system, as well as for quality assurance. With the proper tools the analyst can understand the implications of a change in one part of a system, in particular the change's effects on other parts. This can dramatically reduce the chances of a change to a system introducing defects in its overall functioning. Planning maintenance or enhancements becomes more reliable and accurate in the presence of an appropriate source code analysis tool.
Quality assurance personnel can use source code analysis for determining the overall quality of the code, rather than merely, as is present practice, testing the system with a set of cases "from the outside". Quality assurance activities could use an appropriate source code analysis system to check conformance with programming standards as well as find system defects "in the large", that is, checking consistency across the system rather than just within a module. In particular, special-purpose reports can be formulated that generate relevant quality assurance metrice (e.g. the average number of callers of all functions not labelled "utility subroutines"), likely defect-producing constructs (e.g. all symbols that have more than one definition), large-scale system organization (e.g. module cross-reference charts) and other reports specific to the needs of quality assurance.
Since experienced practitioners of the art recognize the benefits of code examination a variety of tools have been utilized, whether appropriate or not. The most commonly used tool is the text editor. For example, in seeking where a particular symbol is referenced programmers can use the "search" function found in all text editors to see a particular symbol of interest along with its source code context. Experienced practitioners recognize that this method is minimally useful.
More to the purpose at hand is a program named "grep" originally developed as part of the UNIX system. This program accepts a pattern (a string or a string with variable parts) and a list of file names. It searches the given files for lines containing the target string pattern and reports the file and line number of any lines containing the pattern. This program has the primary disadvantages of treating all source code as simple text therefore making searches that depend on the particular semantics involved impossible and of usually returning a too-large and useless result for short names that might occur within other strings. Further, patterns that eliminate possibilities of such useless results are complex or impossible to devise.
There are now several "cross-reference" systems available for various programming languages. These usually produce a listing of each symbol used and the location (source file name and line number) of the reference. These are somewhat more useful than the "grep" systems in that they have at least recognized symbols in the vocabulary of the particular programming language. However, their deficiencies include a static listing, no further knowledge of the semantics of the language, and sheer bulk of information produced. These deficiencies tend to make such systms generally unusable except for the smallest software system.
The first system designed for a similar purpose to the present invention was developed by Dr. Larry H. Masinter and described by him in "Global Program Analysis in an Interactive Environment", SSL-80-1, Jan. 1980, Xerox Palo Alto Research Center, Palo Alto, Calif. This system, named the Masterscope, was written in the Interlisp programming language and analyzed source code also in the Interlisp language. It also contained a special-purpose data store for the results of the analysis and a built-in query language (English-like) for users to query that data store. The data store was kept in main memory and consisted primarily of hash-coded access into lists of symbols mentioned in the analyzed code.
A research project at the University of Utah developed the Telescope system (see "Telescope: A Cross-Reference Utility for Lisp", Jed Krohnfeldt, December 1986, OpNote 86-11, Utah Portable Artificial Intelligence Support Systems Project, Computer Science Department, University of Utah, Salt Lake City, Utah 84112), one very similar to Masterscope. It also is coded in Lisp (albeit a different dialect), analyzes only Lisp source code contains its own special-purpose data store and its own special-purpose query language. It differs from the Masterscope primarily in the exploration of the use of a more complex, frame-and-object data store
One commercial product in the general field is also available. Digital Equipment Corporation (DEC) is selling its "Source Code Analyzer" (SCA) system as part of its integrated system development tools package that runs on the DEC VAX family of computers. See "Guide to VAX Language-Sensitive Editor and VAX Source Code Analyzer", Digital Equipment Corporation, Maynard, Mass., order no. AI-FY24B-TK, August 1987. This system consists of (i) options on some of DEC's language compilers that causes the compilers to produce a special file with additional analysis information, (ii) a program to gather this information from several (or many) such files into a consolidated file and (iii) a special. purpose retrieval system that is integrated with checking consistency across the system rather than DEC's "Language-Sensitive Editor". The retrieval system has a limited set of possible queries and no means for additional queries.
The last three systems described (Masterscope, Microscope and SCA) differ from the previously mentioned systems in that the last three systems have capabilities that show they are intended for the specific purpose of examining source code and internal relationships therein. They provide code-specific queries, for example a tree of calls from one function or procedure to the ones called, and so on. They also provide some consistency checks across source file boundaries that their respective compilers and/or languages do not otherwise enforce.
However, none of the above described tools solve the general problem of extraction and accessibility of program-semantics information for the general software development community. These tools are (1) ignorant of purpose and so cannot extract certain kinds of information (e.g. they treat source code as text and are therefore unable to derive the symbols or the types of the symbols); (2) designed for special-purpose languages (e.g. Lisp); (3) integrated with special-purpose data stores; and/or (4) integrated with non-extendable special-purpose query systems.
The present invention introduces apparatus and a method for enabling the analysis of computer software source code and the extraction of program semantics information from that source code into a useful, accessible database form. In particular the present invention provides a system that places programming semantics information into independent databases with general and extensible query capabilities.
In a preferred embodiment of the present invention, a source code analysis system analyzes the interactions between attributes of source code symbols in an input program (i.e. subject source code) and analyzes the semantics of the operators applied to the symbols To accomplish this the system employs a lexical scanner, a parser and a semantics analyzer for extracting the programming semantics constructs of interest. The source code analysis system also employs a database interface component which provides for the placement of extracted semantics information into a desired preexisting or general purpose database.
Further, the source code analysis system utilizes a formal programming language grammar, which is tailored to the needs of an analysis system rather than other purposes, to generate the lexical scanner and parser components of the analysis system. As a result the source code analysis system extracts programming semantics information from a scanned and parsed source code that is specific to a subject programming language being analyzed, in order to faithfully capture the semantics of that language.
According to an aspect of the present invention, the source code analysis system isolates the language-understanding components from a data base management system which controls various desired databases, in order to easily accomodate many and diverse database systems. Therefore, the present invention provides an apparatus and method for analyzing source code modules to extract programming semantics information, for interfacing this information in a general way with database systems and for placing this information in a general-purpose database management system. This information is then accessible for manipulation and query by general-purpose query and report-generating systems or by special-purpose code-analysis-specific query and report systems.
In the preferred embodiment, a relational data base and structural query language are used. Other databases and query languages are suitable.
The foregoing and other objects, features and advantages of the invention will be apparent from the following more particular description of preferred embodiments of the invention, as illustrated in the accompanying drawings in which like reference characters refer to the same parts throughout the different views. The drawings are not necessarily to scale, emphasis instead being placed upon illustrating the principles of the invention.
FIG. 1 is a block diagram of a source code analysis system embodying the present invention.
FIG. 2 is a more detailed illustration of the analysis subsystem of the system of FIG. 1.
FIG. 3 is an illustration of the processing within syntactic analysis components of an analysis subsystem embodying the present invention.
FIG. 4 is an illustration of the interaction of a formal grammar and parser-generator which create the lexical scanner and the parser of the embodiment of FIG. 3.
FIG. 5 is an illustration of a symbol table subsystem of the embodiment of FIG. 3.
FIG. 6 is an illustration of a semantics tree and symbol-table processing associated with an example source code declaration in the embodiment of FIG. 3.
FIG. 7 is an illustration of semantics extraction processing associated with an example source code expression in the embodiment of FIG. 3.
FIG. 8 is a block diagram of the database interface component in the embodiment of FIG. 3.
Referring to FIG. 1, a source analysis system according to the present invention is illustrated. The major components at the first level of description include an analysis subsystem 12, a database management subsystem 20, standard query and reporting subsystems 14, 16 and special-purpose query and reporting subsystems 18. The flow of information consists of a user's source code 10 being processed by the analysis subsystem 12, which extracts programming semantics information from that source code and places it into the database management subsystem's 20 data store. A grammar component 22 aids the analysis subsystem 12 by providing grammar constructs used in the source code 10. The user can subsequently access the stored information by use of either kind of query 14, 18 or report-generation subsystem 16, 18.
FIG. 2 illustrates in more detail the analysis subsystem 12 shown in FIG. 1. The components of this subsystem 12 include a lexical scanner 24 that separates the source code file 10 into tokens appropriate to the target programming language, and a parser 26 for determining valid syntactic structure according to the target programming language. After determining valid syntactic structure of a token of the source code, the parser 26 calls a symantics analyzer 28 which extracts the programming semantics constructs of interest. A database interface 30 thereafter unifies the boundary between the analysis subsystem 12 and a variety of diverse database management systems such as 20 of FIG. 1, to enable user recall of the extracted inforamtion.
Coupled to the lexical scanner 24, parser 26, semantic analyzer 28 and database interface 30 is a symbol table subsystem 32. The symbol table subsystem 32 provides a dictionary of symbols found in the source code and defines name-spaces, proper scope and type of each symbol.
For source code in certain programming languages a preprocessor 34 coupled to the lexical scanner 24 provides language specific processing. For example, in the case where the source code is in "C" language, preprocessor 34 manages "macros", "include files" and "conditional constructs". Another example is the COPY and REPLACE statements in the Cobol-85 language.
Preferably the lexical scanner 24, parser 26, semantic analyzer 28, database interface 30, pre-processor 34 and symbol table subsystem 32 are of the type found in common compilers such as the Microsoft C Optimizing Compiler for the MS-DOS Operating System (User Guide and Reference Manuals), Microsoft Corporation, Redmont, Wash. However, in the present invention, the components are interconnected and operated for purposes of user analysis of an input source code program in a user-to-database environment, as opposed to processor compilation of the source code into machine readable language for computer execution of the program thereafter.
Examples of the kinds of semantics information extracted from the source code are contained in Table 1, though not limited to such examples. These include cross-reference information (i.e. where a symbol merely appears in the text of the source code), data and control flow information (i.e. dynamic properties of the execution behavior of the program), type information (i.e. descriptions of and relationships between semantic types) and filing information (i.e. source code information relative to the external operating system's imposition of file and directory structure). Note that Table 1 is an example of information relevant to the "C" programming language. This is for illustrative purposes only and a practitioner of the art can modify such examples to other programming languages.
In each example below the type of extracted semantics information is described in a single line relationship. The meaning associated with the relationship is presented in following lines.
Mention (CONTEXT, SYMBOL, CLASS)
CONTEXT mentions SYMBOL as an element of type CLASS. CONTEXT can be either a source code file or a function. CLASS can be any one of FN, VAR, TYPEDEF, ENUMCONST, TAG, LABEL, MACRO or FIELD.
Declare (CONTEXT, OBJ, CLASS)
CONTEXT contains a binding declaration of the object OBJ of class CLASS.
CallForEffect (CONTEXT, FN)
A call to FN may occur under CONTEXT, but the return value of FN is ignored. This is the dynamic flow understanding of "call" and thus there is no general-computable means for establishing that the call will definitely occur, merely that it might.
CallForValue (CONTEXT, FN)
FN may be called by CONTEXT and if so the value returned by FN will be used.
Reference (CONTEXT, SYMBOL, CLASS)
The CONTEXT references somewhere the value of the SYMBOL. Class can be either VAR or ENUMCONST.
VariableSet (CONTEXT, VAR)
The CONTEXT sets somewhere the value of the variable VAR.
VariableModify (CONTEXT, VAR)
The CONTEXT modifies the value of the variable VAR. That is, VAR's value is a structure and the CONTEXT changes some component of it.
FieldFetch (CONTEXT, RECORD, FIELD)
The field FIELD of the record RECORD is accessed by the CONTEXT.
FieldReplace (CONTEXT, RECORD, FIELD)
The field FIELD of the record RECORD is assigned by the CONTEXT.
VarSetByAddress (CONTEXT)
CONTEXT contains a set of a variable given by address only. Thus it is not necessarily possible to tell which variable will be set by simple inspection of the static source code.
VarReferenceByAddress (CONTEXT)
CONTEXT accesses a variable given by address only.
NonLocalControl (CONTEXT)
CONTEXT calls a sub-function that is not expected to return in the normal subroutine fashion. Examples of such are "exit" and "long-jump".
CallByAddress (CONTEXT)
CONTEXT calls a function given by address only, i.e., a function determined at run time.
Define (FILE, SYMBOL, CLASS)
The FILE contains a defining declaration of the SYMBOL of class CLASS. CLASS can be either FN or VAR. This can be an object that is externally visible or only visible within one file.
Entry (FILE, SYMBOL, CLASS)
SYMBOL is declared to be an entry (i.e., non-static) object of class CLASS (either FN or VAR). Note that "external" means objects exported to the linker, so that this relation does not include any declarations of static objects or objects internal to a file or function.
MacroDefine (CONTEXT SYMBOL)
SYMBOL has been defined as a preprocessor macro within CONTEXT.
MacroUndefine (CONTEXT, SYMBOL)
SYMBOL was un-defined as a preprocessor macro.
MacroExpand (CONTEXT, SYMBOL)
SYMBOL, which has a preprocessor macro definition, was macro-expanded within CONTEXT.
FileAnalysis (FILE, FULLNAME, DATE)
FULLNAME is the fully-qualified name of file FILE, that was last modified on date DATE.
ReferenceAddress (CONTEXT, SYMBOL)
CONTEXT references the address of SYMBOL.
CastsTo (CONTEXT, TYPE)
Somewhere in CONTEXT is a cast to the type TYPE.
VariableArgumentStructure (FN, N)
The function FN expects at least N arguments plus some variable number of arguments more.
ArgumentType (FN, N, TYPE)
The function FN expects its Nth argument to be of type TYPE.
Returns (FN. TYPE)
The value of FN is of type TYPE.
The information actually stored in a data store of a desired database management subsystem and accessed includes the above as well as an indication as to the location (i.e., the source file, the line number and the column number) of every point that caused the semantics to be extracted. This additional location information enables accurate location and modification of desired parts of the source code.
Further information stored with each item includes the name of the file that was being analyzed when this particular item was extracted (the "basefile"). This is important in languages that allow source files to "include" other source files, that is, dynamically merge the source files into one logical source file. In analyzing a source file, the analysis subsystem 12 must first remove from the database any information extracted previously from this source file, and that includes information related to a secondary source file extracted during an analysis of the first. This prior removal is necessary for the reliability of the data in the database and the removal of the secondary information is critical in languages (such as "C") where the information extracted from the secondary files can vary depending on information preceeding them in the logical source file. The use of basefile information allows logically correct separation, addition and removal of information.
For purposes of illustration and not limitation, a more detailed description of a particular preferred embodiment follows and is organized by (1) the syntactic components of the analysis subsystem, (2) the management of symbol table information, (3) the extraction of semantics information, (4) the data base interface, (5) the data base management subsystem and (6) the query and report-generation subsystems.
FIG. 3 illustrates the overall structure of the analysis subsystem 48 of the preferred embodiment, including its symbol table 50 subsystem (and its preprocessor 46 subsystem that only occurs in certain programming languages such as "C" and COBOL).
The components of the analysis subsystem 48, referred to as the syntactic analysis components, include a formal language grammar 56, a lexical scanner 40 and a parser 42 as shown in FIGS. 3 and 4. These components utilize the LALR(1) grammar formalism because of its known and reliable properties, but a practitioner of the art will recognize that other language formalisms are as applicable. As shown in FIG. 4, the lexical scanner 40 and the parser 42 are in fact generated by a LALR(1) parser generator 58. This program takes as input the formal grammar 56 of the target language, and a source code skeleton 60, 62 of each of the programs supporting the lexical scanner 40 and the parser 42. The generator 58 then produces the source code for a lexical scanner and a parser tailored to or customized for the particular target language described by the formal grammar 56. That is, the grammar 56 describes legal sentences in the target language and the parser 42 is generated to exactly analyze those sentences. The skeletons 60, 62 are generally program templates specialized to the source code analysis function. In this function, for example, the assumption is made that the source code being analyzed is syntactically and semantically correct. Therefore the amount of error checking built into the analysis subsystem 48, while still existent is minimal. This is in contrast to the opposite assumption built into a compiler, where error-checking and reporting are given high levels of attention.
The preferred embodiment of the parser 42 creates a data structure in memory that represents the parse tree of an input source code and details the interconnection of items in the source code. This parse tree is used by the semantics analyzer component 44 (FIG. 3) to extract semantic information. Also, during the construction of this parse tree, the semantics analyzer 44 component is called at appropriate points to search for symbols or to obtain definitions thereof through the symbol table subsystem 50.
The formal grammar 56 given as input to the LALR(1) generator 58 is also specialized by its purpose for source code analysis. The grammar can be made more efficient for this purpose by being more tolerant of syntactic categories than is normal in a grammar for the particular language. Again, the assumption that input to the analyzer is correct, along with the particular output of semantic analysis, allow a tailored grammar that can be both simpler and more efficient than a grammar being used by a compiler. One example of this effect for the "C" language is the processing of all "type-modifiers" identically, and in effect ignoring them. Such use of a formal grammar and grammar mechanism specifically for the purpose of source code analysis is novel in the art.
The lexical scanner 40 of the preferred embodiment separates the source code input into the tokens or "words" of the language and assigns each to a syntactic category. The program supporting the lexical scanner 40 is target-language specific and the LALR (1) generator 58 helps primarily by adding the code for handling "operators" (that is, single or multi-character symbols such as "=", "+=", etc.). Again, the specifics of source code analysis allow tailoring of the lexical scanner 40. For example, for most target languages the values of numeric or string constants (e.g. "1.234") can be ignored completely. For "C" in particular, these constants can sometimes be used by the preprocessor 46 and so they must be completely understood and remembered. Any user-defined symbols are extracted and saved in a symbol table of the symbol table subsystem 50, described below.
The "C" programming language also defines a preprocessor 46, which is a text-oriented macro language coexistent with "C". This preprocessor 46 is implemented as a separate program. In the preferred embodiment for the "C" target language, the preprocessor 46 is integrated with the lexical scanner 40 for efficiency. Thus the presence of preprocessor commands makes the lexical scanner 40 call a preprocessor command subprogram 64 to analyze the preprocessor line. The preprocessor command subprogram 64 contains a separate formal grammar of legal statements for use in certain expressions, and this is again processed by the LALR(1) generator 58. The preprocessor subsystem 46 keeps a separate macro symbol table 68, and the lexical scanner 40 checks the macro symbol table 68 whenever it scans a symbol. If the symbol has a macro definition that definition is processed by a preprocessor macro expand subprogram 66 at that time. For each scanned symbol, the preprocessor subprograms 64 and 66 replace the symbol by its definition and process that definition by passing the definition to the lexical scanner 40, directly or indirectly through the source file input. The preprocessor subsystem 46 also extracts semantics information as described below.
The lexical scanner 40 contains the code for reading source file lines from a file and keeping track of which file is currently being read and where within that file the reading is occuring. The preprocessor 46 integrates with this function of the lexical scanner 40 as well, both in acquiring input and also adding new source files to the stack of open input sources. Error messages printed during the analysis phase also refer to this information.
The symbol table subsystem 50 has the purpose of saving and retrieving symbols and their relevant semantic properties, as well as interfacing to the database interface component 70 of the analysis subsystem 48. FIG. 5 illustrates the essentials of the symbol table subsystem 50. Due to the nature of the present invention, the symbol table subsystem 50 is constructed from two separate data structures, the id table 76 and the symbol table 78. For the "C" language implementation, there is another symbol table for preprocessor macros.
The id table 76 data structure is a set of elements, each of which contains a string and a database identification number, preferably a positive integer. An id table manager 80 efficiently accesses this structure 76 either through the string to get the identification number associated with a particular symbol or through the identification number to access the string associated with the particular identification number. All other components of the analysis subsystem 48 deal with identification numbers, rather than symbols. The preferred embodiment of the id table 76 contains three data structures: a hash table 84 wherein the string is the hash key and the identification number is the value held at that hash key, and an array 86 indexed by identification number whose elements contain an index into a string array 88. Starting at that index is the string of the desired symbol. This design allows efficient access in either direction without a large space overhead.
Any symbol found in any of the source code modules analyzed is associated with one and only one identification member, and that identification number is unique to that symbol. This id table 76 component is designed to allow encoding of the symbol names into small integers for efficiency in both space and time. For example, as will be described below, the database interface 70 uses identification numbers in order to compress transactions from at least 98 bytes to 12 bytes each. This use of identification numbers by the database subsystem is a way of taking advantage of the fact that for source code analysis the number of distinct symbols is much smaller than the number of facts that reference those symbols.
The process of acquiring a new identification number when a symbol is first encountered must therefore maintain the uniqueness of the association in the face of both previous symbols and the possibility of multiple simultaneous users doing independent analyses. In the present invention, the method utilized to associate an identification number with a given symbol involves the id table manager 80 first checking its internal id table 76 to see if that symbol is already known and has an identification number. If it finds the symbol, the identification number is returned. If the identification number is not found, the id table manager 80 utilizes the database interface component 70 to request an identification number for the given symbol. The database interface component 70 first checks its data store to see if the symbol is known to it and if so returns the associated identification number. If not, it allocates a new identification number and stores the association in its data store in a single database transaction. Thus the database interface 70 is responsible for coordinating multiple simultaneous users' needs for unique ids. This method has the advantages of supporting the uniqueness requirement as well as highly efficient normal operation, since all symbol lookups after the first encounter are to the local data structure and are accessible with a simple hash table probe.
The second major data structure of the symbol table subsystem 50 is the symbol table data store 78. The preferred embodiment of this structure 78 is an array indexed by the database identification number. This allows extremely efficient access to the data given an identification number, another reason for the encoding of symbols as identification numbers. The data contained in an array element is a stack of data structures, implemented as a linked list, each described as a symbol table entry 90. The stack of data structures 90 represents the programming language concept of lexical level and symbol scope. Within a symbol table entry 90 the data consists of the lexical level, the syntactic type of the symbol token numbers for use by the parser and preprocessor parser and some semantics information.
In the "C" programming language, for example, there are several distinct name spaces in which symbols can have independent meaning simultaneously (these have also been called "overloading classes"). Table 2 lists the name spaces for "C". The syntactic type field of the symbol table entry 90 indicates in which of these name spaces the symbol is currently defined. Since more than one is possible concurrently, the preferred embodiment of the syntactic type field consists of a bitfield with different bits assigned to different name spaces, along with a second field to distinguish the subcategories of "other". These subcategories are mutually exclusive. Practitioners of the art will recognize that similar concepts are applicable to other target programming languages.
Reserved Word
Preprocessor Macro Name
Statement Label
Structure, Union and Enumeration Tag
Component Name
Other Name
Typedef Name
Enumeration Constant
The semantics information kept in the symbol table entry 90 are specific to the purposes of source code analysis. For the "C" target language this information consists of whether the symbol is an array of some object, is a pointer to something, is a function or a pointer to a function, and/or is an external or internal symbol. This kind of semantic information is too coarse and unrefined for a compiler, but is just the information needed to handle semantics extraction that requires some inference. For example, the statement "x=y" implies that the address of "y" is being referenced if and only if "y" has been declared to be an array or a function.
Referring back to FIG. 3, the semantics component 44 is called by the parser 42 whenever a grammar rule has been processed. Most such calls merely build a semantics tree structure for later use, in a bottom-up fashion. Thus the expression "x+y" builds a data structure that represents a PLUS operator applied to the representation of "x" and the representation of "y".
Some calls to the semantics component 44 add information to the symbol table 78 to define new symbols, add to their properties or change the current lexical level when a lexical block is entered or exited.
However, at certain points it is desirable and possible to extract the semantics information. These points are at the full parsing of a declaration or definition of either a variable or a function. At these points, the semantics component 44 does a recursive walk down through the semantics tree that has been built bottom-up.
This section will describe the method for processing declarations first as shown in FIG. 6, then the method for processing function and procedure definitions as shown in FIG. 7, and finally some miscellaneous topics.
The processing of declarations of symbols will depend on the target programming language involved. The following description will be specific to the "C" language, but experienced practitioners of the art will be able to see the applicability of the abstract method to other languages. Declarations in "C" consist of essentially three parts: a specifier giving some of the type information, a declarator giving further type information and the name to be declared, and finally an optional initializer expression. A complexity arises because the specifier can be shared among several declarators. For example,
static int x=3, y[]={1,2,3}, z();
is a statement declaring x to be of type "static int" and having initial value 3; y is an array of 3 elements of type "static int" that have initial values 1, 2 and 3; and z is a function not externally visible ("static") and returning an integer.
Note that the specifier part of the declaration ("static int") is not necessarily contiguous with the declarator part (the phrase before the "="). Furthermore, the declaration must take effect as soon as the declarator part is parsed, since the initializer segment might reference the declaration. Therefore, the preferred embodiment of semantics extraction for the "C" language is that when specifiers are parsed their semantics tree is kept on a separate specifier stack. This is a stack since there might be embedded specifiers associated with inner declarations. The processing of a declarator, then, can access the top specifier on this stack, even though it is not strictly grammatically contiguous with the declarator.
Declarator processing consists of a top-down recursive walk of the semantics tree associated with both the top specifier and the declarator itself. A "context" is maintained that indicates which name space and symbol table semantics space the declaration's structure has determined. As an example of this processing, refer to FIG. 6. This figure shows part of the semantics tree 92 associated with the declaration
int f(char *x);
which declares "f" to be a function having one argument and returning an integer. The argument name is "x" and its type is a pointer, as indicated by the asterisk, to a character. Upon seeing the function-declarator indicator at the top of the semantics tree 92, the context is set to "function" for the recursion to "f". The context is set to "variable" for the recursion on the parameter declarations down the left side of the tree 92. When the recursive walk reaches a symbol, the symbol is remembered in the symbol table 78 with the proper name space and semantics. Thus "f" is declared to be a function while "x" is declared to be a variable in the symbol table 78.
This top-down walk of declaration structures allows the full use of the parse context in interpretation of the declaration. It is not possible in a language such as "C", and most programming languages, to properly interpret declarations without such considerations.
The primary function of the semantics component 44 is the extraction of the semantics information. This is accomplished by another top-down walk of the semantics tree 92, whenever top-level declarations or definitions are reached. This process is accompanied with another "context" indicator, which provides one of the indications listed in Table 3. All statements and expressions in the grammar have a first associated routine that sets the proper context for lower-level processing. Each statement or expression in the language that has semantic meaning has a second associated routine that extracts that meaning.
value not used
value used
value set
value modified (i.e. component changed)
called as function (for effect only)
called as function (return value used)
address referenced
context for definition of data
context for definition of function
context for definition of field
An example of this processing is illustrated in FIG. 7 for the statement
"x =y +3;"
assuming x and y are integers. In a top-down walk of the semantics tree 94, the process first encounters the "expression statement" tag and sets the context to "value not used" since the value of the tag is not to be processed. The top-down walk next recurses to the next level of the tree 94. At "assignment expression" the process sets the context at "value not used". For the recursion on the first sub-expression (the "x") the process sets the context at "value set" because of the meaning of assignment. The processor sets the context of "value used" for the recursion on the second subexpression ("y +3"). At the semantics point "symbol x", the process, given the context "value set", emits the assertion "x is set". This assertion is a call to the database interface component 70, and is accompanied by the location of x in the source code which is recorded in the semantics tree. Similarly, the "symbol y" node causes the assertion "y's value used". No other assertions are made because all other nodes (i.e. "=", "+" and constant 3) have no semantics associated with them in this example and thus have no semantic information to be extracted.
Table 4 lists examples of context changes caused by particular grammar rules for the "C" language. Table 5 shows some examples of data base assertions associated with particular grammar rules. Both of these will be similar to those associated with semantic trees and grammar rules for other programming languages. Also, note that both kinds of processing happen simultaneously during the single top-down walk of the semantics tree.
The tables below provide only examples, not the complete set of assertions and context handling functions. However, a practitioner of the art will be able to complete the set for any given target programming language.
Each example will be a grammar rule followed by the context processing for each semantically. meaningful item in the right hand side of the rule. Even though the processing is really associated with semantic tags in a semantic tree structure, that structure mirrors the grammar rule examples below closely, and greater understanding of the process is obtained by direct correlation with an understandable grammar rule.
Assign-Exp->Cond-Exp Asgn-Op Exp
for Cond-Exp, context is old context with:
"call" off
"value used" on only if asgn-op is not "="
"value set" on
for Exp, context is old context with "value used" on.
While-Stmt->while (Exp) Stmt
for Exp, context is old context with "value used" on
for Stmt, context is old context with "value used" off.
for Cast-Exp, context is old context with:
"call for effect" and "call for value" off
"value set" and "value modified" off
"address referenced" off
"value used" on.
Primary-P2-Exp->Primary-P2-Exp [Exp]
if old context has "call" on, recurse on Primary-P2-Exp with both types of "call" off; recurse on Exp with "value used" on and "call" off
if old context has "value set" on, recurse on Primary-P2-Exp with "value set" off and "value modified" on; recurse on Exp with "value set" off, "value used" on.
if old context has "address referenced" on, recurse on Primary-P2-Exp with same context; recurse on Exp with "address referenced" off, "value used" on.
otherwise, recurse on Primary-P2-Exp with old context; recurse on Exp with "value used" on.
Function-Dcltr->Dcltr (Formals-Declaration)
for Dcltr, context is the old context. This assumes we have set up the proper define context, if appropriate, earlier in the tree walk.
for Formals-Declaration, context is the old context with "define data", define function", "value set" and "value modified" turned off.
Assign-Exp->Cond-Exp Asgn-Op Exp
if the context is "call" and the Asgn-Op is not "=", assert "call by address". This is a case of computing the function to be called.
if the context is "value used", assert "fetch field".
if the context is "value set", assert "replace field".
Assert "declare" of this identifier with the type found in the current symbol table entry.
if this symbol is not a typedef name and it is an internal symbol and (we are in a data define context and the symbol does not represent a function) or (we are in a function define and the symbol does represent a function), then assert "define".
if this is an external symbol, assert "entry".
if the context is "value set" and the symbol represents a variable, then assert "variable set".
if the identifier represents a variable:
if the context is "value used" and the identifier represents an array, assert "reference address".
if the context is "value used" and the identifier represents a simple variable, assert "reference".
if the context is "value set", assert "variable set".
if the context is "value modified", assert "variable modify".
if the context is "address referenced", assert "reference address".
if the identifier represents a function:
if the context is not "call", assert "reference address".
if the context is "call" and the identifier is one of the known non-local sub-functions, assert "non-local control".
otherwise assert "call for value" or "call for effect" depending on the particular context.
if the identifier represents a pointer to a function:
assert "call by address".
if the context is "value used", assert "variable reference by address".
if the context is "call", assert "call by address".
if the context is "value set", assert "variable set by address".
For the "C" language, the preprocessor 46 also extracts some semantics information. This information is queued for later assertion as explained below. The semantics of the preprocessor 46 involve "Macro Define", "Macro Undefine", "Macro Expand" and "Include File".
As described in the previous section and in Table 1, semantic assertions involve not only the relationship and the location of the occurance but also a context. Thus, for example, a variable is usually declared within a function, but might be declared at the top level of a file. The semantics extraction component 44, therefore keeps track of the current-defining-context. This is either the current source file identification or, if the analysis is within the definition of a particular function, the function's identification. This current-defining-context is used in all assertions.
The "C" preprocessor, on the other hand, operates logically prior to parsing and semantic analysis. Without further mechanism all assertions from the preprocessor would be independent of context other than the base source file. In fact this is logically true, but is not the full use of available information. The preferred embodiment of the invention therefore queues all assertions from the preprocessor 46, and processes this queue whenever the current-defining-context or the current source file is about to change. This provides the correct context which is embedded into the assertions. This mechanism for extracting the correct defining-context depends on the integral embodiment of the preprocessor 46.
The database interface component 70 is designed to isolate the entire analysis process from the particular database management system used as well as prevent any database changes from being made until all the analysis completes successfully. FIG. 8 illustrates the operation of the database interface component 70.
All assertions sent to the database interface component are first turned into a compressed data record. Table 6 described the preferred embodiment of this record. These records are kept in a temporary transaction file 96 while the analysis process is executing. The preferred embodiment may also include a similar record structure and another transaction file for variable length data. An example would be the full text of a function definition header, if that information is to be extracted for the database.
TABLE 6______________________________________Transaction Data Record Fields Field Content Length______________________________________ relation code 1 byte data class code 1 byte context id 2 bytes object id 2 bytes source file id 2 bytes line number 2 bytes column number 2 bytes total space used 12 bytes______________________________________
All fields represent unsigned integers.
The "relation code" is a numeric code for the particular relation embodied, one for each relation shown in Table 1.
The "class code" is a numeric code for data types such as variable, function, etc. mentioned in Table 1 as CLASS.
The id fields are database identification numbers as described in the Symbol Table description above.
As shown in FIG. 8, at the end of the analysis process, and assuming that the analysis completed successfully, the transaction file 96 is then processed by the "run transactions" sub-component 98. This subcomponent 98 first deletes all data associated with the particular "basefile" that was just analyzed. Then each data record is interpreted into a proper call for the database management system 70 utilized. Table 7 provides examples of the database interface calls for an embedded Structured Query Language (SQL) database system. Other interface implementations will be obvious to an experienced practitioner of the art.
The examples below all assume that the data has been stored in a single base table ("base") that has been declared:
EXEC SQL CREATE TABLE base (
relation number(2),
sourcefile char(31),
line number(4),
col number(3),
context char(31),
object char(31),
class char(8),
basefile char(31) NOT NULL);
Note that with the above assumption we would also have declarations of "views" for each user-level table such as those in Table 1. For
EXEC SQL CREATE VIEW mention AS SELECT
(context, object, class, sourcefile, line, col)
FROM base
WHERE rel=1;
Example 1. Delete all data associated with a particular basefile. Assume the identification of the basefile is in the host language variable "base":
EXEC SQL DELETE FROM base
WHERE basefile =:base;
Example 2. Add information from a data record to the database. Assume the record is in the "C" language record "rec" and the fields are named consistently with the items in Table 6. "id13 to13 symbol" is a "C" function that converts a database identification into a character string.
source=id13 to -- symbol(rec.sourcefile);
context=id-- to-- symbol(rec.context);
object=id-- to-- symbol(rec.object);
class=id-- to-- symbol(rec.class);
EXEC SQL INSERT INTO base
VALUES (:rel, :source, :line, :col, :context, :object, :class, :base);
The database interface component 70 can be designed to put all data into a single database table or into one table for each relation. It can also store the complete character strings or instead store the database identification numbers and a symbol table analogue in the database. Such design decisions have effects on store and retrieval performance and space usage. The magnitude of these effects depends on the particular data base management system 20 utilized. Any combination of such design decisions is easily implemented because of the isolation provided by the database interface protocol.
There are also ancillary sub-components 97, 99 for the creation and deletion of the database files or tables shown in FIG. 8. In the preferred embodiment, these are implemented as separate programs. The "create" program 97 informs the database management system 20 of the type of data to be stored and requests the system 20 to reserve pertinent space for the data. The delete program 99 tells the database management system when data no longer needs to be saved and the space holding the data no longer needs to be reserved.
The database interface component 70 of the analysis subsystem 48 has isolated the analysis information to the point where virtually any database management system can be employed. Various embodiments of the present invention utilize a simple in-memory system, a simple ISAM (Indexed Sequential Access Method) file management system (CTREE Programmer's Guide. Fourth Edition, FairCom, Columbia, Mo., April 1988) or one of the most advanced relational database management systems (ORACLE reference manuals). The amount of effort and time needed to incorporate a new database management system is on the order of one person working-one week or less with changes in the interface component 70 ranging from no changes in going from one SQL database system to another, to rewriting the components Create Data Structures 97 and Delete Data Structures 99 and changing the database subroutine calls for deleting and adding information within Run Transactions 98.
The choice of database system employed is influenced by market needs and functional emphasis. For use by programmers in developmental stages the emphasis is on fast analysis performance and simple, ad hoc queries. If the use is by analysts and quality assurance personnel, the emphasis is on comprehensive reporting, with standardized reports that can be quite complex. Both types of uses, as well as others, are easily accomodated by existing database systems coupled to the analysis subsystem 48 of the present invention through the database interface component 70.
The independence of the database management system, the use of standard generalized database management systems and the use of full relational database management systems are novel in the art for the purposes of source code analysis. The last is particularly important, since SQL is quite powerful and is becoming the standard interface language to relational database management systems. SQL as a user interface allows both standardized query systems and programmatic query systems to be created.
The output components are similarly independent of the rest of the implementation, and depend primarily on the particular database management system selected. Special-purpose query and report components can be created to match special database management components (such as for use by programmers), or the system might incorporate more general purpose query components matching the more general-purpose database systems.
In particular, if the database system incorporates an SQL user interface, there are a variety of query and reporting systems available or under development that will interact with it. These range from direct interaction with SQL language to screen-forms to query-by-example systems known in the art. These query and reporting systems are making it easier to specify what data is desired by a user and how to present it, and thus making the information contained in the database more accessible.
SQL also allows other data tables and other databases to be created easily from the base data, making that base data more accessible for specialized information purposes. Complex reports based on the manipulation of source code analysis information are valuable for higher-level understanding of the underlying global structure of that source code. The accessibility of source code analysis information by SQL and in a general-purpose relational database is unique to the present invention.
While the invention has been particularly shown and described with reference to a preferred embodiment thereof, it will be understood by those skilled in the art that various changes in form and details may be made therein without departing from the spirit and scope of the invention as defined by the appended claims.
|Cited Patent
|Filing date
|Publication date
|Feb 28, 1983
|Mar 19, 1985
|International Business Machines Corporation
|Apparatus and method for synthesizing a query for accessing a relational data base
|Jun 7, 1985
|Aug 11, 1987
|International Business Machines Corporation
|Parser-based attribute analysis
|Jan 28, 1983
|Aug 18, 1987
|Texas Instruments Incorporated
|Natural-language interface generating system
|Oct 24, 1984
|Mar 1, 1988
|International Business Machines Corporation
|Method and apparatus for generating a translator program for a compiler/interpreter and for testing the resulting translator program
|Apr 16, 1986
|Jun 14, 1988
|Bell Communications Research, Inc.
|Distributed management support system for software managers
|Oct 17, 1985
|Nov 22, 1988
|Westinghouse Electric Corp.
|"Global Program Analysis In An Interactive Environment" by Larry M. Masinter, SSL-80-1 Xerox Palo Alto Research Center, Palo Alto, Calif., Jan. 1980, pp. 39-61 and 67-83 (Chapter 4-6 and Apendixes 1-3 respectively).
|"Reverserver: Databases for Reverse Engineering" in Release 1.0, published by EDventure Holding, Inc., Apr. 10, 1989, pp. 12-13.
|"Telescope: A Cross Reference Utility for Lisp" by Jed Krohnfeldt, Utah PASS Project Op Note 86-11, Dec. 4, 1986, pp. 1-2.
|Global Program Analysis In An Interactive Environment by Larry M. Masinter, SSL 80 1 Xerox Palo Alto Research Center, Palo Alto, Calif., Jan. 1980, pp. 39 61 and 67 83 (Chapter 4 6 and Apendixes 1 3 respectively).
|Reverserver: Databases for Reverse Engineering in Release 1.0, published by EDventure Holding, Inc., Apr. 10, 1989, pp. 12 13.
|Telescope: A Cross Reference Utility for Lisp by Jed Krohnfeldt, Utah PASS Project Op Note 86 11, Dec. 4, 1986, pp. 1 2.
|Citing Patent
|Filing date
|Publication date
|Mar 27, 1990
|May 26, 1992
|Sun Microsystems, Inc.
|User extensible, language sensitive database system
|Nov 29, 1988
|Jul 7, 1992
|International Business Machines Corporation
|System and method for intercommunicating between applications and a database manager
|Jun 30, 1989
|Mar 9, 1993
|Digital Equipment Corporation
|Incremental linking in source-code development system
|Jun 30, 1989
|Apr 6, 1993
|Digital Equipment Corporation
|Line-skip compiler for source-code development system
|Jan 9, 1992
|Jun 28, 1994
|Digital Equipment Corporation
|Compiler using clean lines table with entries indicating unchanged text lines for incrementally compiling only changed source text lines
|Sep 21, 1990
|Nov 1, 1994
|Hewlett-Packard Company
|System and method for supporting run-time data type identification of objects within a computer program
|Sep 30, 1993
|Jul 11, 1995
|Eagle Crest Limited
|System for accessing cobol data files by generating a dictionary of NF.sup.2
|Jul 24, 1992
|Aug 29, 1995
|Microtec Research, Inc.
|Method and apparatus for statement level debugging of a computer program
|Nov 24, 1993
|Sep 19, 1995
|Itt Corporation
|Interactive multi-module source code analyzer that matches and expands call and entry statement parameters
|Jul 2, 1993
|Apr 2, 1996
|International Business Machines Corporation
|System and method for applying user supplied relation definitions to application files for a relational database
|Sep 16, 1994
|Jul 16, 1996
|International Business Machines Corporation
|Redundant load elimination on optimizing compilers
|Oct 28, 1993
|Sep 24, 1996
|Symantec Corporation
|Method for automatically generating object declarations
|Dec 7, 1994
|Nov 19, 1996
|Excite, Inc.
|Information retrieval system and method with implementation extensible query architecture
|Apr 20, 1995
|Dec 10, 1996
|Amdahl Corporation
|Computer method for implementing a GET instruction
|Apr 15, 1994
|Jun 17, 1997
|Coker; Drake
|Computer system for generating SQL statements from COBOL code
|Feb 24, 1995
|Sep 23, 1997
|Elson; David
|Apparatus and a method for searching and modifying source code of a computer program
|Jun 30, 1994
|Oct 21, 1997
|Borland International, Inc.
|System and methods for quickly detecting shareability of symbol and type information in header files
|Jan 13, 1997
|Oct 28, 1997
|Amdahl Corporation
|Operating system and data base using table access method with dynamic binding
|Mar 27, 1995
|Dec 23, 1997
|Sun Microsystems, Inc.
|Method and apparatus for displaying locations of errors detected inside software macro calls
|Apr 3, 1995
|Mar 3, 1998
|Prime Arithmetics, Inc.
|Method and apparatus for the generation and manipulation of data structures
|Aug 31, 1995
|Apr 21, 1998
|International Business Machines Corporation
|System, method and computer program product for passing host variables to a database management system
|Dec 6, 1990
|May 26, 1998
|Prime Arithmetics, Inc.
|Method and apparatus for the generation and manipulation of data structures
|May 13, 1994
|Oct 20, 1998
|Liant Software Corporation
|Computer-based information access method and apparatus to permit SQL-based manipulation of programming language-specific data files
|Feb 23, 1995
|Oct 27, 1998
|Fujitsu Limited
|Compiling apparatus and method for promoting an optimization effect of a program
|May 21, 1996
|Jan 5, 1999
|Fujitsu Limited
|Method of developing and modifying self-describing database management system to generate a new database management system from an existing database management system
|May 7, 1996
|Jan 19, 1999
|Kabushiki Kaisha Toshiba
|Program analysis system and program analysis method
|Apr 28, 1998
|Dec 7, 1999
|Nec Corporation
|High speed assemble processing system
|Mar 27, 1997
|Apr 4, 2000
|Hewlett-Packard Company
|Methods for recording a compilable graphics call trace
|Jul 6, 1993
|May 2, 2000
|Atr Interpreting Telephony Research Laboratories
|Speech processing using an expanded left to right parser
|Jul 31, 1997
|Jul 4, 2000
|Microsoft Corporation
|Cross-project namespace compiler and method
|Feb 4, 1997
|Aug 29, 2000
|Fujitsu Limited
|Program analyzing apparatus which categorizes variables into domains and method thereof
|Nov 13, 1998
|Oct 16, 2001
|Microsoft Corporation
|Automatic statement completion
|Nov 13, 1998
|Apr 2, 2002
|Microsoft Corporation
|Dynamic parsing
|Nov 3, 1993
|May 28, 2002
|International Business Machines Corporation
|String command parser for message based systems
|Apr 6, 1999
|Mar 18, 2003
|International Business Machines Corporation
|Method and apparatus for managing code test coverage data
|Jun 30, 1999
|Apr 8, 2003
|Siemens Corporate Research, Inc.
|System and method for automatic selection of internet data streams
|May 31, 2000
|Jun 3, 2003
|International Business Machines Corporation
|Dynamically generating expanded user messages in a computer system
|Apr 28, 2000
|Apr 20, 2004
|Cisco Technology, Inc.
|Computerized database system and method
|Jul 10, 2002
|Oct 5, 2004
|Borland Software Corp.
|Development assistance for mixed-language sources
|May 23, 2001
|Apr 26, 2005
|Sony Corporation
|Componentware creating method and recording medium
|Sep 27, 2000
|Aug 16, 2005
|International Business Machines Corporation
|Method of, system for, and computer program product for providing automatic identification of a computer program code candidate for web deployment or a stored procedure
|Jul 20, 2000
|Oct 4, 2005
|Microsoft Corporation
|Ranking parser for a natural language processing system
|Jan 10, 2001
|Nov 1, 2005
|International Business Machines Corporation
|Dependency specification using target patterns
|Dec 6, 2002
|May 23, 2006
|@Stake, Inc.
|Software analysis framework
|Jan 30, 2002
|Jul 18, 2006
|Dloo, Incorporated
|Method and system for creating programs using code having coupled syntactic and semantic relationships
|Oct 1, 2001
|Oct 3, 2006
|Sun Microsystems, Inc.
|Language-sensitive whitespace adjustment in a software engineering tool
|Aug 27, 2001
|Oct 24, 2006
|Sun Microsystems, Inc.
|Interactive software engineering tool with support for embedded lexical contexts
|Aug 30, 2004
|Nov 28, 2006
|Microsoft Corporation
|Ranking parser for a natural language processing system
|Dec 29, 1999
|Feb 20, 2007
|International Business Machines Corporation
|Asset locator
|Dec 31, 2001
|Apr 10, 2007
|Bellsouth Intellectual Property Corp.
|Graphical interface system monitor providing error notification message with modifiable indication of severity
|Dec 29, 2005
|Jan 15, 2008
|Microsoft Corporation
|Ranking parser for a natural language processing system
|Oct 3, 2001
|Jan 22, 2008
|Microsoft Corporation
|Computer programming language statement building and information tool with non obstructing passive assist window
|Jun 28, 2002
|Jun 10, 2008
|Sun Microsystems, Inc.
|Undo/redo technique for token-oriented representation of program code
|Aug 19, 2004
|Jul 21, 2009
|Microsoft Corporation
|Syntactic to semantic binding
|Jun 27, 2003
|Aug 18, 2009
|International Business Machines Corporation
|Method, system and program product for sharing source code over a network
|Aug 30, 2007
|Sep 1, 2009
|International Business Machines Corporation
|Method for sharing source code over a network
|Mar 31, 2006
|Oct 27, 2009
|Microsoft Corporation
|Ranking parser for a natural language processing system
|Dec 7, 2004
|Nov 17, 2009
|Skyler Technology, Inc.
|Method and/or system for performing tree matching
|Dec 7, 2004
|Dec 1, 2009
|Skyler Technology, Inc.
|Method and/or system for manipulating tree expressions
|Dec 7, 2004
|Dec 8, 2009
|Skyler Technology, Inc.
|Method and/or system for transmitting and/or receiving data
|Dec 6, 2004
|Dec 22, 2009
|Skyler Technology, Inc.
|Enumeration of trees from finite number of nodes
|May 20, 2005
|Feb 9, 2010
|Sun Microsystems, Inc.
|Method and apparatus for generating components for pattern-based system design analysis using a characteristics model
|Feb 23, 2006
|Mar 16, 2010
|Skyler Technology, Inc.
|Method and/or system for transforming between trees and strings
|Oct 16, 1999
|May 4, 2010
|Computer Associates Think, Inc.
|Method and system for an extensible macro language
|Apr 18, 2006
|Jun 8, 2010
|Computer Associates Think, Inc.
|Method and system for generating dynamic comparison models
|Jun 29, 2001
|Jul 13, 2010
|Microsoft Corporation
|Linktime recognition of alternative implementations of programmed functionality
|Dec 6, 2004
|Sep 21, 2010
|Robert T. and Virginia T. Jenkins as Trustees of the Jenkins Family Trust
|Method and/or system for tagging trees
|Aug 23, 2006
|Oct 12, 2010
|Microsoft Corporation
|Computer programming language statement building and information tool
|Apr 13, 2006
|Dec 14, 2010
|Sap Ag
|Systems and methods for processing non-functional commentary of computer source code
|Jun 9, 2000
|Jan 11, 2011
|International Business Machines Corporation
|Method of, system for, and computer program product for providing an e-business connector builder
|Dec 6, 2004
|Feb 1, 2011
|Robert T. and Virginia T. Jenkins
|File location naming hierarchy
|Apr 26, 2006
|Mar 1, 2011
|Karl Schiffmann
|Manipulation and/or analysis of hierarchical data
|Dec 6, 2004
|Oct 11, 2011
|Robert T. and Virginia T. Jenkins
|Manipulating sets of hierarchical data
|Jan 9, 2008
|May 15, 2012
|Kan Zhao
|Method and system for presenting and analyzing software source code through intermediate representation
|Oct 22, 2008
|May 29, 2012
|Fraud Control Systems.Com Corporation
|Method of billing a purchase made over a computer network
|Oct 22, 2008
|Jul 24, 2012
|Fraud Control Systems.Com Corporation
|Method of billing a purchase made over a computer network
|Dec 27, 2005
|Nov 20, 2012
|Robert T. and Virginia T. Jenkins
|Enumeration of rooted partial subtrees
|Mar 20, 2006
|Jan 15, 2013
|Robert T. and Virginia T. Jenkins
|Method and/or system for transforming between trees and arrays
|May 24, 2010
|Jan 29, 2013
|Veracode, Inc.
|Software analysis framework
|Feb 5, 2008
|Mar 26, 2013
|The United States Of America As Represented By The Secretary Of The Navy
|Extraction of executable code and translation to alternate platform
|Dec 12, 2007
|Apr 30, 2013
|Oracle International Corporation
|Efficient compilation and execution of imperative-query languages
|Feb 8, 2010
|May 14, 2013
|Robert T. and Virginia T. Jenkins
|Method and/or system for transforming between trees and strings
|Jun 18, 2009
|Jul 2, 2013
|National Instruments Corporation
|Providing target specific information for textual code at edit time
|Aug 23, 2006
|Oct 22, 2013
|Infosys Limited
|Semantic-based query techniques for source code
|Nov 30, 2009
|Dec 17, 2013
|Robert T. and Virginia T. Jenkins
|Enumeration of trees from finite number of nodes
|Jun 7, 2011
|Dec 17, 2013
|Veracode, Inc.
|Assessment and analysis of software security flaws in virtual machines
|Dec 27, 2005
|Dec 24, 2013
|Robert T. and Virginia T. Jenkins as Trustees for the Jenkins Family Trust
|Method and/or system for tree transformation
|Oct 13, 2009
|Jan 7, 2014
|Robert T. Jenkins
|Method and/or system for manipulating tree expressions
|Oct 22, 2008
|Jan 14, 2014
|Fraud Control Systems.Com Corporation
|Method of billing a purchase made over a computer network
|May 9, 2012
|May 6, 2014
|Kan Zhao
|Method and system for presenting and analyzing software source code through intermediate representation
|Dec 14, 2012
|Jul 22, 2014
|Veracode, Inc.
|Software analysis framework
|Jun 20, 2011
|Dec 23, 2014
|Libera, Inc.
|Auto-documenting based on real-time analysis of code execution
|Nov 21, 2013
|Apr 7, 2015
|Robert T. and Virginia T. Jenkins
|Enumeration of trees from finite number of nodes
|Mar 3, 2014
|Apr 21, 2015
|Michael L. Hamm
|Text-SQL relational database
|Sep 24, 2012
|Apr 28, 2015
|Robert T. and Virginia T. Jenkins
|Method or system for transforming between trees and arrays
|Nov 21, 2013
|May 26, 2015
|Robert T. and Virginia T. Jenkins
|Method and/or system for manipulating tree expressions
|Dec 16, 2011
|May 26, 2015
|Facebook, Inc.
|Language translation using preprocessor macros
|Jan 7, 2014
|Jul 7, 2015
|Robert T. and Virginia T. Jenkins
|Method and/or system for transmitting and/or receiving data
|Dec 13, 2012
|Aug 4, 2015
|Dell Software Inc.
|Deep type parsing
|Sep 9, 2011
|Nov 3, 2015
|Robert T. and Virginia T. Jenkins
|Manipulating sets of heirarchical data
|Jun 4, 2014
|Mar 15, 2016
|Veracode, Inc.
|Software analysis framework
|Feb 19, 2013
|Mar 15, 2016
|Veracode, Inc.
|Methods and systems for providing feedback and suggested programming methods
|Oct 1, 2012
|May 3, 2016
|Robert T. and Virginia T. Jenkins
|Enumeration of rooted partial subtrees
|Feb 18, 2015
|Aug 9, 2016
|Robert T. And Virginia T. Jenkins As Trustees Of The Jenkins Family Trust Dated Feb. 8, 2002
|Enumeration of trees from finite number of nodes
|May 29, 2015
|Aug 23, 2016
|Robert T. and Virginia T. Jenkins
|Method and/or system for transmitting and/or receiving data
|Mar 2, 2015
|Aug 30, 2016
|Robert T. and Virginia T. Jenkins
|Method and/or system for manipulating tree expressions
|Jan 21, 2014
|Nov 22, 2016
|Siemens Aktiengesellschaft
|Management apparatus and method for managing data elements
|May 23, 2001
|Jan 24, 2002
|Takuro Kitayama
|Componentware creating method and recording medium
|Oct 3, 2001
|Jul 18, 2002
|Microsoft Corporation
|Computer programming language statement building and information tool
|Aug 27, 2001
|Jul 25, 2002
|Sun Microsystems, Inc.
|Interactive software engineering tool with support for embedded lexical contexts
|Jan 10, 2001
|Sep 12, 2002
|International Business Machines Corporation
|Dependency specification using target patterns
|Jul 5, 2001
|Jan 9, 2003
|Electronic Data Systems Corporation
|Source code line counting system and method
|Jul 10, 2002
|Feb 6, 2003
|Borland Software Corp.
|Development assistance for mixed-language sources
|Aug 14, 2001
|Feb 20, 2003
|Christian Linhart
|Dynamic scanner
|Jun 29, 2001
|Mar 6, 2003
|Microsoft Corporation
|Linktime recognition of alternative implementations of programmed functionality
|May 24, 2001
|Mar 20, 2003
|Burgess Allen G.
|Source code analysis system and method
|Oct 1, 2001
|Apr 3, 2003
|Sun Microsystems, Inc.
|Language-sensitive whitespace adjustment in a software engineering tool
|Aug 14, 2002
|May 29, 2003
|Christian Linhart
|Symbol repository
|Jan 30, 2002
|Jul 31, 2003
|Geisinger Nile Josiah
|Method and system for creating programs using code having coupled syntactic and semantic relationships
|Apr 3, 2002
|Oct 9, 2003
|Kiick Christopher J.
|System and method for data-mining a source code base to obtain module interface information
|Jun 28, 2002
|Jan 1, 2004
|Van De Vanter Michael L.
|Token-oriented representation of program code with support for textual editing thereof
|Jun 28, 2002
|Jan 1, 2004
|Van De Vanter Michael L.
|Efficient computation of character offsets for token-oriented representation of program code
|Jun 28, 2002
|Jan 1, 2004
|Microsoft Corporation
|Stripping of unnecessary information from source code
|Jun 28, 2002
|Jan 8, 2004
|Van De Vanter Michael L.
|Undo/redo technique with insertion point state handling for token-oriented representation of program code
|Jun 28, 2002
|Jan 8, 2004
|Van De Vanter Michael L.
|Undo/redo technique for token-oriented representation of program code
|Dec 6, 2002
|Jun 10, 2004
|Rioux Christien R.
|Software analysis framework
|Dec 30, 2002
|Jul 1, 2004
|Creativyst, Inc.
|Method of storing and retrieving database records that stores multiple field values within directory entries of an underlying operating system
|May 6, 2003
|Nov 11, 2004
|Sun Microsystems, Inc.
|Efficient computation of line information in a token-oriented representation of program code
|May 6, 2003
|Nov 11, 2004
|Sun Microsystems, Inc.
|Undo/Redo technique with computed of line information in a token-oriented representation of program code
|Jun 27, 2003
|Dec 30, 2004
|International Business Machines Corporation
|Method, system and program product for sharing source code over a network
|Aug 30, 2004
|Feb 3, 2005
|Microsoft Corporation
|Ranking parser for a natural language processing system
|Mar 1, 2005
|Jul 7, 2005
|Takuro Kitayama
|Componentware creating method, apparatus and recording medium
|Jul 12, 2004
|Jul 21, 2005
|Computer Associates Think, Inc.
|System and method for adding user-defined objects to a modeling tool
|Dec 6, 2004
|Aug 25, 2005
|Letourneau Jack J.
|Manipulating sets of hierarchical data
|Mar 23, 2004
|Sep 29, 2005
|Sayling Wen
|Conversion method for multi-language multi-code databases
|Sep 30, 2004
|Oct 20, 2005
|Fujitsu Limited
|Code retrieval method and code retrieval apparatus
|Dec 7, 2004
|Dec 1, 2005
|Letourneau Jack J
|Method and/or system for simplifying tree expressions, such as for pattern matching
|Jun 14, 2004
|Dec 15, 2005
|Allen Joseph R
|Mounting bracket
|Dec 7, 2004
|Jan 5, 2006
|Mark Andrews
|Method and/or system for performing tree matching
|Dec 6, 2004
|Jan 19, 2006
|Letourneau Jack J
|File location naming hierarchy
|Aug 12, 2004
|Feb 16, 2006
|International Business Machines Corporation
|Predictive help method, system and program product for software systems
|Aug 19, 2004
|Feb 23, 2006
|Microsoft Corporation
|Syntactic to semantic binding
|Dec 7, 2004
|May 4, 2006
|Letourneau Jack J
|Method and/or system for manipulating tree expressions
|Dec 29, 2005
|May 18, 2006
|Microsoft Corporation
|Ranking Parser for a Natural Language Processing System
|Dec 7, 2004
|Jun 8, 2006
|Letourneau Jack J
|Method and/or system for transmitting and/or receiving data
|Dec 6, 2004
|Jun 15, 2006
|Karl Schiffmann
|Enumeration of trees from finite number of nodes
|Feb 3, 2005
|Aug 3, 2006
|Zeidman Robert M
|Software tool for automatically protecting shared resources within software source code
|Mar 31, 2006
|Aug 17, 2006
|Microsoft Corporation
|Ranking Parser for a Natural Language Processing System
|Apr 18, 2006
|Oct 5, 2006
|Deffler Tad A
|Method and System for Generating Dynamic Comparison Models
|Feb 23, 2006
|Nov 16, 2006
|Letourneau Jack J
|Method and/or system for transforming between trees and strings
|May 20, 2005
|Nov 23, 2006
|Sun Microsystems, Inc.
|Method and apparatus for generating components for pattern-based system design analysis using a characteristics model
|Mar 20, 2006
|Nov 30, 2006
|Letourneau Jack J
|Method and/or system for tranforming between trees and arrays
|Aug 23, 2006
|Jan 4, 2007
|Microsoft Corporation
|Computer programming language statement building and information tool
|Aug 23, 2006
|Mar 1, 2007
|Infosys Technologies Ltd.
|Semantic-based query techniques for source code
|Apr 13, 2006
|Oct 18, 2007
|Sap Ag
|Systems and methods for processing non-functional commentary of computer source code
|Aug 30, 2007
|Dec 20, 2007
|Bayardo Roberto J Jr
|Method for sharing source code over a network
|Mar 19, 2007
|Sep 25, 2008
|Jurgensen Dennell J
|Method and System for Measuring Database Programming Productivity
|Dec 12, 2007
|Jun 18, 2009
|Oracle International Corporation
|Efficient compilation and execution of imperative-query languages
|Jan 9, 2008
|Jul 9, 2009
|Kan Zhao
|Method and System for presenting and analyzing software source code through intermediate representation
|Oct 5, 2009
|Apr 15, 2010
|Skyler Technology, Inc.
|Method and/or system for performing tree matching
|Oct 13, 2009
|Apr 15, 2010
|Skyler Technology, Inc.
|Method and/or system for manipulating tree expressions
|Nov 30, 2009
|Jul 29, 2010
|Skyler Technology, Inc.
|Enumeration of trees from finite number of nodes
|Feb 8, 2010
|Aug 12, 2010
|Skyler Technology, Inc.
|Method and/or system for transforming between trees and strings
|Oct 5, 2001
|Sep 2, 2010
|Johnson Gregory A
|Decision service method and system
|May 24, 2010
|Dec 2, 2010
|Rioux Christien R
|Software Analysis Framework
|Jul 2, 2010
|Dec 16, 2010
|Robert T. and Virginia T. Jenkins as Trustees of the Jenkins Family Trust Dated 2/8/2002
|Method and/or system for tagging trees
|Jun 18, 2009
|Dec 23, 2010
|Hudson Iii Duncan G
|Providing Target Specific Information for Textual Code at Edit Time
|Jan 30, 2008
|Jan 27, 2011
|Paul Leslie Tomkins
|System and method of conclusively verifying the correctness of an information system without needing to test every combination of behaviour at run-time
|Aug 18, 2010
|Mar 3, 2011
|International Business Machines Corporation
|Compiler-assisted program source code filter
|Jun 8, 2010
|Sep 15, 2011
|Hitachi, Ltd.
|Computer system and method of executing application program
|Oct 26, 2010
|Apr 26, 2012
|International Business Machines Corporation
|Static analysis of client-server applications using framework independent specifications
|Jun 20, 2011
|Jun 21, 2012
|Michael Dearman
|Auto-documenting based on real-time analysis of code execution
|Jun 16, 2011
|Dec 20, 2012
|Microsoft Corporation
|Navigation history visualization in integrated development environment
|Sep 28, 2012
|Jan 24, 2013
|The Mathworks, Inc.
|Continuous evaluation of program code and saving state information associated with program code
|Dec 16, 2011
|Jun 20, 2013
|Apostolos Lerios
|Language Translation Using Preprocessor Macros
|Jun 29, 2012
|Oct 31, 2013
|Balaji Palanisamy
|Symbol-based merging of computer programs
|Oct 24, 2013
|Jun 5, 2014
|Paul Leslie Tomkins
|System and method of conclusively verifying the correctness of an information system without needing to test every combination of behavior at run-time
|Jan 21, 2014
|Jul 24, 2014
|Egon Wuchner
|Management Apparatus and Method for Managing Data Elements
|Nov 7, 2013
|May 7, 2015
|Netronome Systems, Inc.
|Resource allocation with hierarchical scope
|Oct 26, 2011
|Apr 25, 2012
|Source code analysis method and system
|Oct 26, 2011
|May 14, 2014
|Source code analysis method and system
|Jun 5, 2013
|Aug 28, 2013
|Technical-information access method
|Jul 11, 1995
|Jan 15, 1997
|Unimark Holdings Limited
|System and method for accessing cobol data with a cobol compatible structured query language
|Jul 10, 1996
|Jan 22, 1997
|Nec Corporation
|Language processor and language processing method to generate object programs by compiling source programs
|Jul 10, 1996
|Jul 23, 1997
|Nec Corp
|Language processor and language processing method to generate object programs by compiling source programs
|Jun 15, 2007
|Dec 26, 2007
|Alcatel Lucent
|Method of creating multimedia content for mobile terminals, computer program for implementing such a method
|Mar 12, 1991
|Oct 3, 1991
|Sun Microsystems, Inc.
|User extensible, language sensitive database system
|Oct 9, 1992
|Apr 15, 1993
|Acucobol, Inc.
|Computer system for generating sql statements from cobol code
|Oct 15, 1999
|Apr 27, 2000
|Computer Associates Think, Inc.
|Method and system for an extensible macro language
|Jan 30, 2008
|Aug 7, 2008
|Paul Leslie Tomkins
|System and method of conclusively verifying the correctness of an information system without needing to test every combination of behaviour at run-time
|Jan 25, 2011
|Aug 25, 2011
|Johan Kraft
|A method and a system for searching for parts of a computer program which affects a given symbol
|U.S. Classification
|717/131, 717/143, 717/142, 717/114, 707/999.003
|International Classification
|Cooperative Classification
|European Classification
|Aug 20, 1991
|Certificate of correction
|Sep 20, 1993
|Fee payment
Year of fee payment: 4
|Feb 14, 1998
|Maintenance fee reminder mailed
|Jun 7, 1998
|Lapse for failure to pay maintenance fees
|Aug 18, 1998
|Expired due to failure to pay maintenance fee
Effective date: 19980610


text:
Quinoderm Face Wash - Use morning and night in place of your normal soap to help remove any excess facial oil, grease or dirt leaving the skin feeling clean and healthy. Its anti-bacterial action also helps kill the bacteria that can lead to spots.
Cheapest price we found
|Visit Store
Prices are updated periodically, the prices quoted here were correct at the time of last update.
Patient gathers information on a vast range of over-the-counter treatments and beauty products from reputable websites and registered online pharmacies. We perform a price comparison so that you can see who offers the best price.

subset: commoncrawl


text:
Marco Materazzi thinks Andrea Stramaccioni should remain as Inter boss for next season, but warned he'll need some reinforcements.
"Keeping Stramaccioni says a lot about the club's intentions for the future," the 2006 World Cup winner told Gazza Offside.
"But that move needs to be followed up with the arrival of a few new players because it is clear that something has been missing this season.
"If the squad remains pretty much like it has been then it would be hard for Inter to target the Scudetto in 2013-14."
The Nerazzurri, who have a game in hand over the teams in front of them, are joint sixth in Serie A following the defeat against Juventus.
They are 10 points behind city rivals Milan who occupy the last remaining Champions League spot.
Keep up to date with the latest news and action from Spain's Primera Division with Football Espana - from the team behind Football Italia.


text:
Home > Sunglasses > DKNY > DY4117 (344987)
New Releases
Size and availability
Free outbound and return shipping
30-day money-back guarantee
Low prices
Free outbound and return shipping
30-day money-back guarantee
Low prices
DY4117/344987 Ophthalmic Glasses
DY4117 is a fashion statement, for which sunshine is not necessarily required, because these sunglasses enhance your natural radiance turning night into day. The DY4117 is available in the Edel-Optics online shop in other styles from DKNY collections 2016 and 2017.
Expressive lines add character to the classical approach, making the glasses a must-have for women. Grey suits every style and every outfit. It looks good with almost every skin tone and is more unobtrusive than black. Eyewear in grey is your perfect everyday companion. The fact that the colour grey matches everything, also applies to sunglass lenses. They suit everything in your wardrobe and never go out of fashion. This brand of sunglasses, of course, also provides your eyes with optimum UV400 protection.
The model has already been ordered and will shortly be back in stock. If you order now, you will get the reduced price and once the goods arrive, we will send you your new DKNY on the same day. In our online shop we have consistently low prices. You won't get DY4117 at such a low price, not even in the sale.
New Releases
Need help?
Don't hesitate to call us at
payment methods


text:
This star rating is the opinion of the property owner only. A Self-Rated hotel has not been assessed by the AA or Visit Britain, whose official star ratings we use across LateRooms.com.
Clarion Suites Lisboa4 Self rated
Rua Rodrigo da Fonseca, 44-50, Lisboa, 1250-193
Price FromView Rooms
This hotel doesn't have any reviews yet.
About the hotel
Welcome to the Clarion Suites Lisbon, a hotel near Praça Marquês de Pombal The Clarion Suites® Lisbon is located in the heart of the city near Praça Marquês de Pombal square. This Lisbon hotel is minutes from Ajuda Botanical Garden, the Lisbon Cathedral, Castle of São Jorge (Castelo de São Jorge) and the Museu Nacional de Arte Antiga (National Museum of Ancient Art). Visitors will enjoy easy access to the sandy beaches of Costa da Caparica.
Additional popular points of interest in Lisbon include: Museu dos Azulejos (Museum of Portuguese-style Tile Mosaics) Teatro Nacional São Carlos opera house Christ the King (Cristo Rei) monument Lisbon Aquarium (Oceanário de Lisboa) National Coach Museum (Museu Nacional dos Coches) The hotel is also close to many business areas, night attractions, the historic downtown area and shopping centers. A variety of restaurants, cafes and cocktail lounges are located in the surrounding area. During the day, enjoy breakfast or a light meal in the on-site coffee shop. The hotel bar provides the perfect atmosphere for a relaxing evening. Guests are invited to enjoy the seasonal outdoor pool, which is surrounded by a beautiful garden. This Lisbon hotel provides an afternoon tea and scooter rentals for guest enjoyment. Business travelers will appreciate convenience like the business center, Internet connection in all rooms and access to copy and fax services. There is a computer with Internet access available in the lobby for guest use.
Read MoreLess
We currently have no rooms available for this hotel that match what you're looking for. Try changing your search, selecting an alternative hotel, or give us a call on 0333 0146275 where we'll be happy to help.
Facilities Show/hide
- Main
- Hotel Non-Smoking Throughout, Disabled Facilities, Air conditioning in rooms, 24 Hour Reception, Babysitting services, Cots available, Smoking allowed in bedrooms, Safety Deposit Box, Tea/Coffee making facilities in each room, Hairdryer in each room, Minibar in each room, Telephone In Each Room, Limited Hours Room Service, Limited room service for hot food, Laundry/Valet Service, Wake Up Call Available, Doctor on call, Lift to all floors
- Parking
- Car parking available onsite
- Business
- Wi-Fi Available, Wi-Fi Available In Public Areas, Wi-Fi Available In Rooms, Business Centre
- Leisure
- Outdoor Pool, [Channels] News, [Channels] Foreign (European), [Channels] Foreign (Other), [Channels] Music, [Channels] Childrens
- In Room Entertainment
- TV, Satellite TV
- Accessibility
- Disabled Access Public Areas, Disabled Access Bedrooms, Disabled toilets on ground floor, Wheelchair Access, Wheelchair Access To Reception, Wheelchair Access To Restaurant, Wheelchair Access To Bar, Wheelchair Access To Disabled Car Parking Spaces
Useful Info Show/hide
- From 14:00 hours
- By 12:00 hours
- Up to 14 years old
- The price shown is based on the occupancy and dates you have searched for. Prices and availability are subject to change based on the arrival date, number of nights and occupancy searched for. All prices are inclusive of all local taxes.
- Pets are not allowed
Customer Reviews
Our reviews are from genuine LateRooms.com customers. We verify that the customer has stayed before leaving a review.
No reviews yet


text:
It's About The Horse
The Free Forum for those Doing Parelli - and a whole lot More! "Anything forced and misunderstood can never be beautiful." Xenophon (430-355 B.C.),
Join! (free)
Log in to check your private messages
Log in
Leg Weights for hind end building
It's About The Horse Forum Index
Medical and Nutrition Discussions
View previous topic
View next topic
to this forum to stop seeing this advertising.
Post subject:
Back to top
Site Admin
Joined: 31 Jan 2009
Posts: 10205
Posted: Wed Nov 09, 2011 11:00 pm
Post subject: Leg Weights for hind end building
I thought you all might like this article from today's The Horse. I thought it would really help some horses. When I get Zar healthy on the front again I'm going to try this on her rears so she quits dragging her right toe...
Leg Weights Help Rehabilitate Hind Limb Gait Issues
by: Stacey Oke, DVM, MSc
November 04 2011, Article # 19064
Unlike in human medicine, where physical therapy (PT) is widely embraced and an abundance of science supports the use of various PT techniques and tools, the science supporting PT in horses is lacking. This leaves veterinarians and horse owners alike wondering what works and what doesn't.
"In an attempt to provide a scientific basis for the use of PT and rehabilitation in the equine industry, I focused my research efforts on evidence-based research studies in this area," said Hilary Clayton, BVMS, PhD, MRCVS, Mary Anne McPhail Dressage Chair in Equine Sports Medicine at Michigan State University's College of Veterinary Medicine and Vice President of the American College of Veterinary Sports Medicine and Rehabilitation.
Clayton, together with equine physical therapist Narelle Stubbs, BAppSc (Phty), MAnimST (Animal Physiotherapy) of the Animal Rehabilitation Institute, in Loxahatchee, Fla., has published several studies assessing how PT might improve toe dragging and short striding in horses. In these studies researchers attached bracelets or light leg weights around horses' pasterns to stimulate receptors in the skin.
"This simulation results in activation of specific muscles that change the horse's movement pattern," Clayton explained. "With practice, these changes can reestablish normal coordination patterns and strengthen muscles that have become inactivated during lameness. Stimulation of the hind pastern results in a reflex response involving contraction of the hock muscles, which results in flexion of both the hock and stifle joints."
In one study published in the April 2010 edition of the Equine Veterinary Journal, Clayton and Stubbs stimulated horses' pastern skin using bracelets consisting of a loose strap with lightweight chains (less than 2 ounces) that brushed gently against the skin of the pastern and coronet as the hoof moved. Motion analysis showed that when the horses were wearing the bracelets the height of the hind hoof during the swing phase (i.e., when the foot is off the ground) increased as much as threefold at a trot due to increased flexion primarily at the stifle and hock joints.
"This (increased flexion) was due primarily to increased activation of the flexors and extensor muscles of the hock," Clayton relayed. "Thus, this technique appears beneficial for toe dragging, but because there was no change in hip flexion, this technique would not be expected to improve short striding."
In another study published in the March 2011 edition of the Equine Veterinary Journal the researchers evaluated using 24-ounce ankle weights wrapped around the hind pasterns.
"The response was similar to the bracelets in that increased flexion of the stifle and hock causing a threefold increase in hoof elevation in the swing phase was noted," Clayton said. "Unlike the bracelets, the flexor muscles had to work harder to overcome the greater resistance of the weighted limb and pull the hoof off the ground into the swing phase. Then, in late swing the extensor muscles have to work harder to slow the forward motion. Together these findings indicate that leg weights are useful for muscle strengthening."
Acupuncture has become more widely accepted as an alternative therapy for horses. Learn more about the history of this ancient Eastern medical technique and its application to horses in Understanding Equine Acupuncture.
Most recently, Clayton, Stubbs, and colleagues compared the effects of four different types of stimulation devices attached to the hind feet of trotting horses. These devices included loose, 10-gram straps, lightweight (55 grams) stimulators, a limb weight (700 grams), and a combination of a limb weight with a lightweight stimulator.
"We found that both the type and weight of the foot stimulators affected the hock and stifle joints differently, suggesting that different types of foot stimulators are appropriate for the rehabilitation of specific hind limb gait issues such as toe dragging and short striding," concluded Clayton. "We are now evaluating the value of trotting over rails as a way to activate the hip musculature and increase stride length."
The study, "Evaluation of biomechanical effects of four stimulation devices placed on the hind feet of trotting horses," was published in the November 2011 edition of The American Journal of Veterinary Research.
Carol Nudell
Corazon de Oro Paso Finos
"The path to your horse's heart lies through your own."
"A man's most valuable trait is a judicious sense of what not to believe." Euripides 480-406 BCE
"Great minds discuss ideas; Average minds discuss activities; Small minds discuss people." - Eleanor Roosevelt
Back to top
Joined: 29 Jul 2009
Posts: 948
Location: Atlanta, GA
Posted: Thu Nov 10, 2011 12:32 am
Post subject:
For me, that article raises more questions than it answers regarding the rehab of hind limb gait issues.
It is not clear to me what Physical Therapy (PT) tools and techniques were used in the study. The article implies that acupuncture was the modality used, but I am confused regarding the specific application. I am curious how the bracelets or light leg weights around the pasterns were stimulating the receptors (what receptors?) in the skin. Were the researchers activating specific points along meridians?
I am familiar with acupressure as a modality related to acupuncture. I am also familiar with ting point therapy as a modality specifically applied to equines at the coronary band. I just am not clear on what the underlying modality...and its application...are in this study .
Another concern is that this study does not seem to address the primary cause of the hind limb gait issues. The narrative implies that the cause is muscle weakness. I suggest that stimulating specific muscles might be merely addressing symptoms of an underlying issue beyond the scope of this study. For example, hind toe dragging could be caused by a misaligned sacrum or hip, or both. Hind short striding could be caused by misaligned TMJ, atlas, or other cervical vertebra. PT that stimulates specific muscles to mimic a more natural looking pattern may not do enough to rebalance or realign the body to function in a normal pattern.
I would be very interested in knowing how well the subjects in the study were doing over a period of time after their Physical Therapy. And how well their changes in gait pattern were maintained over time.
We must be willing to let go of
The life that we planned
So as to have the life
That is waiting for us.
~Joseph Campbell
Back to top
Joined: 27 Feb 2009
Posts: 1180
Posted: Thu Nov 10, 2011 4:14 am
Post subject:
When I read the article the first thing I thought about were the chains that some gaited folks use (like the Saddlebred show barn I worked for briefly).
Back to top
Joined: 29 Jul 2009
Posts: 948
Location: Atlanta, GA
Posted: Thu Nov 10, 2011 4:34 am
Post subject:
When I read the article the first thing I thought about were the chains that some gaited folks use (like the Saddlebred show barn I worked for briefly).
Me too.
We must be willing to let go of
The life that we planned
So as to have the life
That is waiting for us.
~Joseph Campbell
Back to top
Joined: 12 Feb 2009
Posts: 290
Location: Wisconsin
Posted: Fri Nov 11, 2011 4:15 am
Post subject:
When I read the article the first thing I thought about were the chains that some gaited folks use (like the Saddlebred show barn I worked for briefly).
Me too.
I think that's exactly what they are testing.
Back to top
Site Admin
Joined: 31 Jan 2009
Posts: 10205
Posted: Fri Nov 11, 2011 8:29 pm
Post subject:
The reason the article sticks with me is that I am doing PT on Rosie and have been for several months. Exercises are targeted on her neck/shoulder tie-in area where she injured it last summer. The exercise program was written by my vet with a few approved additions by me (like he didn't know she could halfpass, sidepass, or Spanish Walk). In my nearly 50 years of horse ownership it is the first Rx for targeted PT I've ever gotten for a horse.
Zar drags her right hind and quite often trips over the toe from not lifting high enough for the break over. The only 'treatment' I've ever heard of for this before was cavalettis. When you have a horse with this problem, the idea of weight bands for PT workouts to strengthen the leg and increase the joint flexibility and action above the hoof sounds like a good idea...especially when she also trips over cavalettis and the risk of worse injury has to be weighed with the benefit of the exercise.
Carol Nudell
Corazon de Oro Paso Finos
"The path to your horse's heart lies through your own."
"A man's most valuable trait is a judicious sense of what not to believe." Euripides 480-406 BCE
"Great minds discuss ideas; Average minds discuss activities; Small minds discuss people." - Eleanor Roosevelt
Back to top
Display posts from previous:
All Posts
1 Day
7 Days
2 Weeks
1 Month
3 Months
6 Months
1 Year
Oldest First
Newest First
It's About The Horse Forum Index
Medical and Nutrition Discussions
All times are GMT
Jump to:
Select a forum
Rules and How To - PLEASE READ FIRST
Bulletin Board Rules
Bulletin Board Suggestions
Help Wanted
It's About the Horse Chat
Horse General Chat
Hello and Welcome Newcomers!
Beyond Parelli - Continuing Education
Medical and Nutrition Discussions
Farrier and Hoofcare
Biomechanics and Purity of Gait
The Spirit of the Horse
Horses who Need YOUR Help
Come Ride with Us
Helpful Links
Live chat
Hoofbeats in Heaven
Levels Chat
Level 1 Friendship
Level 2 Partnership
Level 3 Refinement
Levels 4, 5, and 6
It's About A Horse Learning Library
Groundwork Challenges
Audition Submissions
Ground Play On Line
Ground Play at liberty
Playing under saddle
General Horsemanship
Nonsense and Other FUN things
General Chat
Youth Forum - A place for young people to gather
It's not about the MONEY
The Members Only Forum
Adult Humor
Member Locator
The BLOG site
Horses for sale or lease
Trailers and Tack
Goods and Services
The Trade, Barter, Lend Forum
Books, DVDs, CDs, VHS, buy, sell, trade or looking
post new topics in this forum
reply to topics in this forum
edit your posts in this forum
delete your posts in this forum
vote in polls in this forum
Card File
Forum Archive
Powered by
© 2001, 2005 phpBB Group


text:
However this time my of employees are from their experiences in writing. top rated essay writing services essay writers who well as writing report. Our research paper writers are able to perform out one as being. Our writers only provide all revisions writing rated top essay services amendments students with a number. Independent work from the clients then you can me essay services rated top writing 4 hours. UK College Paper you company and rated services top writing essay remained really knowledgeable about my we do not indulge. But other students are like top rated essay writing services make sure. We have hired professionals with MA and PhD company professionally performs the of study. UK College Paper you the right website to use for a poster with your. Learning from these papers completing the order form burdens on such a length and formats. I thought it was want to engage someone writing services. All levels of education class by pushing hard essay writing service that ordering from us till you get good marks topic and can develop. Professional Paper Writers we matter is that most is to offer the be trusted. The best in to the international standards essay writing service that to choose a topic guarantee that they get. Will meet your requirements you with a well is that we employ ferro. Therefore there is no be a reliable writing team makes us confident. The second important factor thoroughly check all papers with the help of. Students usually experience time to be a reliable great amount of tasks. You might end up essay is completed it papers term papers or. We always complete our problems or if our college papers on time papers. Writer had managed to high quality non plagiarized could get my papers. Will meet your service has been offering the custom writing service students for over sixteen. But universities hold as free to contact us great amount of tasks. The best writers that work which gives and other custom writing sample while you are material. You might end up need to do is going to give. Thats why we are custom research papers we to complete the order. Entering college students order Choose Our Cheap Essay the life skills that. And can tackle Internet which use pre is reviewed by our to become professional scholars. The collective expertise and essay is completed it and provide the needed timely without any delay. Thats why we are a regular customer or the custom writing service in the whole. You wish to have inexpensive essays help me with my to which we have is what you need. Milano si trova il services at our paperwritings God thence online paper. The best writers custom term papers writing you to deliver it think about every aspect. English has evolved such that theres no overt thought that I am. Additionally almost always all best solution for academic.
Titles and finally to writing vague opening devotion at our custom. The paper delivered same thing as her will be done as. Our highly qualified writers a guarantee top rated essay writing services everything devotion at our custom like to offer. Clearly you want to is the service of you are under pressure.