JP2000357083A - Method and device for processing document and storage medium - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a method and a device for processing document with which a document and processing related thereto are coupled in a structure. SOLUTION: An agency 400 placed between a client 402 and a server operates an agent 401 for processing a document to be exchanged between the client 402 and the server. The agent 401 is the set of active documents and the active document is a structured document containing a text and/or action. The active document is operated corresponding to the context of a character string, stream or purse tree on a network, can embed a program and is the structured document so that the program has the same syntax as the document.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

[0001] The present invention relates to the field of document processing. More particularly, one aspect of the present invention provides an improved method and apparatus for processing documents, text and programs in the same and maintainable manner.

[0002]

BACKGROUND OF THE INVENTION The present invention relates to the field of document processing. More particularly, one aspect of the present invention provides an improved method and apparatus for processing documents, text and programs in the same and maintainable manner.

[0003] With the development of the Internet, a large network of many small computer networks and interconnecting individual computers, many people in software development and distribution plans have realized that many people are interconnected. Use. For example, Sun Micros
ystems (Mountain View, CA, USA)
By using a program written in the Java (registered trademark) programming language, which is developed by the Company, a software provider puts a copy of the program on the Internet, and many Internet clients make the program exist as if it were on a client machine. You can run as if you were.

As used herein, an "Internet server" is a computer or group of computers connected to the Internet and responding to given requests. An "Internet client" is a computer or group of computers connected to the Internet and sending requests to an Internet server. One computer or group of computers may act as a client for one set of requests and a server for another set of requests.

[0005] There are several protocols commonly used for processing requests and responses to them, depending on the nature of the request. For example, FTP (File Transfer Protocol)
l) is a protocol used by a client to request a file from a server. HTTP (HyperText Tr
Ansport Protocol is a protocol used by a client to request a hypertext document, and by a server to return a requested document or transfer an activated object. Hypertext documents linked to other hypertext documents that are viewed using an HTTP browser have been collectively referred to as the "World Wide Web" or "Web". These protocols are usually TCP / IP
It operates on top of a lower level protocol known as (Transport Control Protocol / Internet Protocol). Each of these protocols is described in detail in existing literature and will not be described further.

[0006] The HTTP protocol is a protocol developed from a conventional static hypertext document transfer protocol. With this protocol, a server manages the nature and parameters of a request from a client and the server itself. The hypertext document can be quickly generated based on the current "session" status for the client and various other factors. For example, instead of making a request for a static legacy hypertext page stored on a server, the CGI
(Common Gateway Interface) You could make a request for a script like a script. If there is such a script, the client sends a request to the server, and even if the request can specify either a static document or a script, the server determines that the request is for a script and Executes the script and returns the output of the script as a result of the request.

FIG. 1 explains the mechanism of the operation of such a script system. Figure 1 Browser 1
2 and the server 14 are shown, on which the server supervisor 20 runs. The server supervisor 20 processes input / output with the browser 12 (the client in this example), accesses one or more CGI scripts such as a form 22 and a script 24, and sends an output 26 of the script 24 to the browser. To accumulate. Although not shown, the browser 12 and the server 1
4 may be interposed between the network and the Internet.

FIGS. 2 and 3 show examples of the form 22 and the script 24 in FIG. 1, respectively. In operation, browser 12 requests a reference from server 14, which is interpreted by server 14 as a request for form 22. As seen in FIG. 2, form 22 is a form for requesting a user of browser 12 for a name and telephone number. The form 22 is sent to the browser 12, which presents the user with an appropriate form to fill out. Browser 12 displays form 22 according to the instructions contained therein. In this example, these instructions are HTML (HyperText Markup Language; Sta
ndard is a form of tagged text in the Generalized Markup Language "SGML").

[0009] When the server 14 is provided with the completed form, the server 14 passes the completed form to the script 24. In this example, script 24 is called "phone.cgi" and is referenced in form 22. Script 24
As can be seen from FIG. 3, it is described in a script language known as PERL. The output 26 of the script 24 for a certain input form is PERL
Can be determined with the recognition that
hank you. Your entry was: "followed by the name and phone number entered. The script also converts the input data to" p
honebook.txt ".

[0010]

One problem with such a method is that the combination of two different skills and, in many cases, two separate skills, to coordinate form creation and scripting. This requires a combination of product developers. The form developer may be an HTML-savvy technical writer, but will need to coordinate with the programmer who writes the PERL code so that the names and fields of the variables in the form match the variable names and inputs in the script . Adjustments are also needed for other languages, such as Java and C.

Thus, it can be seen that there is a need for an improved method and apparatus that integrates a document with its associated behavior (program). The present invention seeks to provide such an improved method and apparatus.

[0012]

According to the present invention, a document and its associated processes are structured by structuring the document according to a common structure applicable to both the document itself and the processes applied to it. Be combined.

[0013] In one embodiment of the present invention, a client
In a server document processing system, an agency is interposed between the client and the server, and the agency operates one or more agents that process documents exchanged between the client and the server. Each agent is a collection of active documents, which are structured documents containing text and / or behavior. An agent can also be considered a software object with the behavior specified by the active document.

An active document operates on a network in a context of a character string, a stream, and a parse tree.
Since the program can be embedded and is a structured document, the program has the same syntax as the document. Further, since the document is structured, its elements can be used as a data structure.

An application field of the document processing system is a network office device on the web utilizing a standard protocol and a software agency that combines the functions of a client, a server, and a proxy.

One advantage of active documents and agency systems is that client software and server software need only perform at a low level, since higher levels of functionality can be implemented as active documents. When development is performed using the active document language, a single unified language is used to specify the content (data) and processing (behavior) of the document, so that computer processing for the document can be easily implemented.

Another advantage of such an active document based document processing system is that the agent itself can be described as an active document.

The nature and advantages of the present invention will be more fully understood from the description in connection with the embodiments. To facilitate the understanding, the methods included in the present invention will be listed below. .

(1) A method of processing an input structured document to generate an output document that is a processing result: a) Initializing a parser cursor to point to a first element of the input structured document. Initializing an input parser, including: b) coupling an element input of an element processor with the input parser to receive a current element from the input parser, and coupling an element output of the element processor to an output generator. , The step of initializing the element processor; c) the step of initializing a definition table coupled to the element processor; d) receiving an element sequence from the input parser, and replacing each element with the following 1) to 6) Processing by steps: 1) inputting an element from an element input of the element processor; 2) determining whether the element is an active element; Determining the element; 3) if the element is a passive element, using the applicable definition obtained from the definition table to evaluate the passive element and passing the result to the element output; 4) if the element is an active element, performing the following steps 1) and 2): i) coupling the element output to an input of an active element queue; and ii) obtained from the definition table Evaluating the active element using the applicable definition and passing the result to the element output; 5) coupling the element input to the output of the active element queue if the active element queue is not empty. And 6) if the active element queue is empty and the element input is not coupled to the input parser,
Combining the element input with the input parser; and e) generating the output document using the output generator.

(2) The document processing method according to (1), wherein the output document is a null document when each processed element is evaluated as a null character string.

(3) The document processing method according to (1), wherein the input structured document, the output document, and the definition table are each represented by a common structured document format.

(4) The document processing method according to (3), wherein the common structured document format is SGML.

(5) In the first document processing method,
Determining whether an element is an active element or a passive element includes: a) comparing the element identifier to an active tag table; b) a matching active tag is found in the active tag table. Qualifying the element as an active element; and c) when a matching active tag is
Certifying the element as a passive element when the element is not found in the table.

(6) In the document processing method of the above (5), the comparing step is a step of comparing the element identifier with an active tag found in the definition table.

(7) Evaluating the passive element includes: a) replacing the token in the passive element with an applicable definition obtained from a definition table; and b) there is no primitive expression in the passive element. Evaluating the primitive expression.

(8) Evaluating the passive element includes: a) matching the element with a set of passive actor criteria; and b) matching if the element matches a criteria of a passive actor. Invoking a passive actor method for each passive actor.

(9) In the document processing method of (1), the step of processing an active element includes: a) replacing at least a passive token in the active element with an applicable definition obtained from the definition table. B) evaluating the primitive expression, if any, in the active element; and c) invoking an active actor action method with the active element as a parameter. Processing method.

(10) A method of processing an input structured document by an active document interpreter to generate an output document, comprising: a) parsing the input document to determine an element including a start tag, an end tag, and an entity reference; Obtaining a parse sequence consisting of a sequence; b) performing the following steps 1) to 6) for each element encountered in said parse sequence: 1) said element is a passive element or an active element Where the active element is the element with the associated handler in the handler database maintained by the active document interpreter; 2) the element's child elements are in the parse sequence 3) when the element is a passive element and has no child elements, Passing the passive element to the output process; 4) when the element is a passive element and has a child element, processing the child element by step b) and repeating the processing as necessary; 5) the element Is an active element and has child elements, processing the child elements by the following steps i) and ii): i) processing the child elements by step b), and performing the processing as necessary Iterating; and ii) step a) sending the element output in 5) i to a storage queue; and 6) if the storage queue is not empty, the input analyzed until the storage queue is empty. Using the storage queue as a source of the parse sequence instead of a document; and c) defining in the output process each element output to the output process. The step of processing according to the output rule set, a document processing method comprising.

(11) In the document processing method according to (10), the step of providing a passive element to the output process further includes: a) determining whether an entity reference for the passive element is defined in an entity definition set. And b) outputting the corresponding entity value of the defined entity reference when the entity reference is defined in the entity definition set.

(12) In the document processing method of (10), steps a) and (a) are performed so that the input structured document can be at least partially processed without referring to the entire input structured document. b) and c) are executed almost simultaneously.

(13) The document processing method according to (10), wherein steps a), b) and c) are sequentially executed.

(14) The document processing method according to (10), wherein the processing operations of steps a), b) and c) are expressed in the same syntax as the input structured document.

(15) The document processing method according to (10), wherein the handler database is expressed in the same syntax as the input structured document.

(16) A document processing device (active document interpreter) that processes an input structured document represented by a parse tree and generates an output document: a) traversing the parse tree when requested An input document tree traverser that outputs a current element, wherein the current element is an element pointed by a cursor in the parse tree; b) the input document for processing an element output by the input document tree traverser An element processor coupled to the tree traverser; c) an output document tree constructor coupled to the element processor for constructing an output document tree with elements output by the element processor; d) an input element is an active element A first element within the element processor for determining whether the element is a passive element.
E) a first router inside the element processor for sending a passive element to an output stage of the element processor and an active element to an element queue; f) a corresponding entity replacement value for the input element A) a second element evaluator inside said element processor to find out from the definition table; and g) sending an element from said element queue to said second element evaluator and output of said element processor when said element queue is not empty; A document processing apparatus, comprising: a second router inside the element processor for sending an element from the input to the element processor when the element processor is empty.

(17) A method of processing an input document to obtain an output document, comprising: a) analyzing the input document to obtain a sequence consisting of an element start tag, an element end tag, an entity reference, and a character string. B) replaces the input document with 1) each defined entity reference with a sequence of instructions that, when executed, outputs a defined replacement value; 2) replaces each element identified as an active element when executed , Take the output of the instruction corresponding to the attribute and content of the element as input, replace it with the instruction sequence that is passed from the definition of the active element to the instruction sequence derived by this method, and 3) represents a primitive operation When each recognized element is executed, it takes in the output of the instruction corresponding to the attribute and content of the element as input, and By replacing the unrecognized element start tag, element end tag, entity reference, and character string with an instruction sequence that outputs it, with the instruction sequence performing the indicated primitive operation; and A document processing method comprising: converting the instruction sequence into an instruction sequence; and c) executing the obtained instruction sequence to create an output document.

(18) A computer readable program recorded with a program for causing a computer to execute any one of the above (1) to (15) or the processing for the document processing method of the above (17). Storage media.

(19) A computer-readable storage medium on which a program for causing a computer to realize the functions of the document processing apparatus according to (16) is recorded.

[0038]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS Preferred embodiments of the present invention and some modifications will be described below with reference to the accompanying drawings. It will be apparent to those skilled in the art that many of the details of the embodiments described below can be changed without departing from the scope of the invention.

A document-oriented computer processing system appears to be a network of agencies that exchange documents with each other. One example is the Personal Information Agency (PIA) described in US patent application Ser. No. 08 / 718,858, filed Sep. 24, 1996 (hereinafter “Savitzky”).

In such a system, an input device,
The output device and the storage device are easy to handle because they are all just compound documents. Since the input device is the source of the document, from the perspective of an agent requesting a document from the input device, the input device can be a single document that is constantly updated, a growing collection of documents, or one or more destinations. It may look like a client who constantly sends documents to the Nation. The output device is a sink of documents, and may look like an updatable document, eg, a growing collection of documents, or a client constantly requesting documents from one or more sources. The storage device has aspects of both an input device and an output device, and can send documents to the storage device for later retrieval.

The PIA device disclosed in Savitzky can be used for implementing document processing as described below,
It should be understood that other devices could be used in place of the Savitzky PIA device. Further, a document processing agency that does not have all the components or functions included in the PIA disclosed in Savitzky can also use the document processing described below.

FIG. 4 shows a personal information agency (PIA) for processing active documents.
It is a block diagram of. As shown, PIA 400 is:
It includes several agents that process active documents exchanged between client 402 and a server (not shown) or other nodes on the network (not shown). The client 402 used here is, for example, a browser, and the active document passed from the client 402 usually takes the form of a document request or an input result.

Referring now to FIG. 4, there is shown a method of using an active document 404 instead of the form 22 and script 24 shown in FIGS. 2 and 3, respectively. FIG. 6 shows the contents of the active document 404.

The active document 404 is a document used not only by the agent 401 to process the information when it is received, but also to display a user input form on the browser 402. 7 and 8 show two browser displays 602 and 604.
Is shown. Browser display 602 is the form that will appear for user input, and browser display 604 is the active document processing result that will appear on the browser screen as a result of providing form 602. Both displays are generated by the same active document 404.

According to the active document, since the behavior can be embedded in the document, the obtained single component document can be easily managed, the form can be interpreted by itself, and the table and other data can be used. Is self-maintaining because it is organized in the same document as the code required for its maintenance. By taking this to the next stage, the entire system (eg, the entire agent) can be implemented as a collection of active documents that require nothing else.

In the preferred embodiment, the active document is
HTM that may include additional tags, according to GML syntax conventions
L document. By doing this, ordinary text
The document can be edited with an editor. In such a "computer processing of documents" technique, data and methods are H
It is just a component of a TML document. For example, HTML lists (indicated by <ul> and <ol> tags) are used by programs as lists or arrays. The definition list (<dl> tag) also serves as a linking sequence in that the term (<dt> tagged text) corresponds to data (<dd> tagged text). Similarly, tables (<table> tags) can be used as database tables. This is done in consideration of utilizing an existing text structure as program data.

In general, all data in the active document is in the form of SGML "elements", where the elements are (1)
One character string, (2) start tag, (3) end tag, or (4) entity reference. In the example shown here,
The start tag includes a “<” character, an identifier (“tag”), a variable number of “attribute = value” pairs, and a “>” character. The end tag is composed of a “<” character, a tag, and a “>” character. Entities are “&” characters, identifiers, and “;”
Consists of characters. A structure including a start tag, an end tag corresponding to the start tag, and contents enclosed by the start tag and the end tag is called an “element”. Tags and text are collectively referred to as "tokens." Plain text is called text, while tags and entities are called markup. Some operations only work on text or some only on markup. An entity is a special notation, such as HTML “&copy;” representing a copyright symbol, and can be used as a variable or a macro. As such, an entity is definable, redefinable, and expandable (ie, an entity can be replaced by its current definition). Entities can also be used as "iteration variables". One example of using an iteration variable is when you want to embed each item in a list in a block of text.

In the preferred embodiment, any subset of the tokens in the document can be associated with a software object called the "actor" that you want to activate. Each actor contains either SGML content or a reference to a primitive handle (subroutine).
When the element replaced by the content appears in the document, the actor is expanded, ie, the handle subroutine is called, and the entity is combined with the attribute and content of the element. Actors can be grouped into groups called "tag sets."

Actors are associated with tokens in two ways. An "active" actor has an entry in a hash table that associates it with the tag identifier of the corresponding element. If no active actor matches the element, each actor in the "passive" actor set is examined in turn for a list of matching criteria that checks for token characteristics (usually attributes). For example, the "if" actor is active and matches the start tag <if>. ”_F
The "oreach" actor is passive and matches any start tag that includes a "foreach" attribute. Another possible actor is the "_eval_perl_" actor, which is also passive and has a "perl" value of "language" Matches any start tag that contains an attribute.

Although the PIA defines a standard set of tags for use in active documents, some agents may define a special set of tags to load with this standard set of tags. Completely different tag sets can be defined for heterogeneous document processing, such as HTML parsing, formatting, and even translating SGML documents of other document types into HTML.

The concepts described above are closely related to both the interpretation of the programming language and the formatting of the document. Because active documents have two characteristics, the technical writer associates actors with macros and associates entities with abbreviations and document evaluation processes as formatting or typesetting, while programmers do not associate actors with functions. May associate an entity with a variable.

FIG. 9 is a flowchart of a generalized process that can be used to interpret an active document. The object that interprets the active document is called the active document interpreter (ADI). ADI provides actions and handles for most agents.
Implements the method. The ADI processes an input document to create an output document and, in some cases, causes additional operations other than output document generation, such as reading and writing a file.

The ADI is for the input stack, the parse stack, the output queue, and the current token T, the "streaming / parsing" flag, the "processing / quoting" flag, the current tag set and the list of "handler" actors. And a state memory that holds the value of Each item on the input stack is a token or an object that returns the next token in the token sequence. When a token is requested, ADI examines the top item on the input stack. If there are tokens available on the stack, the next token is requested, but if there are no tokens available, the stack is popped and the next item is examined.

The input stack is typically initialized to hold one token, the "scanner" object. The scanner object splits the input file or character stream into tokens. The input stack will also be initialized to hold an object that traverses (ie, traverses) the software representation of the element and returns the element's start tag, content, and end tag.

ADI reads one token at a time from the input stack. A token can be a start tag, an end tag, or a complete token such as a string, empty tag, entity reference, or parse tree. Initially, the process is in a streaming state, and the token is processed as soon as it is received.
Another processing state is a parsing state. When the token read is the start tag, the token is pushed onto the parse stack along with the parsing / streaming and quote flags. If the token read is an end tag that matches the start tag at the top of the parse stack, the top one on the parse stack is popped and the state is "
If the token is an end tag that does not match the one at the top of the parse stack, the token is pushed onto the input stack and the omitted end tag is omitted as if it were a "parse". The process returns to the streaming state and the "streaming" flag is popped.

Then, the current token T is processed as follows. If the token is an entity reference and the value is defined in the current entity table, the token is replaced with the value (text, element or token list).
Next, if the current token T is a token list or an element with content, the token is pushed onto the input stack so that its start tag, content and end tag can be processed separately. If the current token is not such and is neither an entity reference nor a token list, the current token is a start tag, end tag, empty tag, or text.
If the current token is a start tag or an empty tag, any entities in that attribute are expanded (ie, replaced with their values).

Next, the tag identifier of the token is searched in the current tag set table of the active tag. When a matching actor is found, the act_on () method of the actor is called with the current token and the ADI itself as parameters.
If no matching actor is found, the token T
The passive actor list of the current tag set is consulted for actors with criteria that match, and the act_on () method of each such actor is called.

The act_on () method will change the parsing / streaming and processing / quoting flags of the ADI, or replace the current token T with another token or a null value (delete token). This method will also push one or more actors to the "handler" list. After the processing of the act_on () method, if the handler list is not empty and the processing / quotation flag indicates processing, the handle method of each actor in the handler list is called. At this point, if the token T is not null, the parsing / streaming flag is examined. In the parsing state, T is added to the contents of the token (element) at the top of the parse stack. If streaming, T is added to the output queue.

An important point of the above procedure is that a document that is a passive document can be processed in the same manner as an active document.
Passive documents are simply processed and output (when the parsing / streaming flag is set to streaming) or parsed to generate a parse tree (when the parsing / streaming flag is set to parsing). On the other hand, the active document causes the methods contained in it to be executed. For an active document containing actors, the process is more complicated.

Next, another implementation of the active document interpreter will be described. In this implementation, the input to the AID is a parse tree iterator. Here, the parse tree is a set of nodes and represents an input document. An example of a parse tree is described in the document object model of the WWW Consortium (for example, see <http://www.w3.org/TR/PR-DOM-Level-1/>).

The iterator is initialized to the root node of the document's parse tree, and the ADI can advance its input iterator to the next sibling node or first child node of the current input node. The current input node is handled in exactly the same way as the current token in the first embodiment. The absence of the next sibling node indicates the "end tag" condition.

The output of the AID is a parse tree constructor. The processing for such a constructor includes adding a new child node to the current node, adding a new child node to the current node, making the child node the current node, and setting the parent node of the current node to the current node. To make it the new current node. A
DI operates by recursively traversing its input tree. Normal (inactive) nodes are copied to the output tree. The active node has a new A
Expanded by instantiating DI. The output of this new ADI is the same as its "context", but the input is an iterator of the definitions of those active nodes. The attributes and contents of the original active node are
Combined with the entity name that can be accessed within the expansion result.

Since input iterators and output constructs work only positively, it is possible to process files with a parser emulating such traversal without having the entire tree resident in the ADI. Similarly, the output constructor can output the internal representation of each passed node without building a real parse tree.

For specialized document processing tasks such as filtering, other specialized input iterators and output constructors can be utilized. It will be appreciated by those skilled in the art that many other equivalent implementations are possible, such as, for example, converting each node in the parse tree of the active document into an equivalent instruction sequence in a programming language that outputs the desired expansion result. Will be obvious. In such an implementation, the first pass converts the active document into a program, and the second pass executes the program to perform processing operations.

Here, the InterForm language for active document processing developed by the inventors will be described in detail in order to understand some terms used below.

Converting an input token is called "parsing". As a result of parsing, ADI
Create a composite object consisting of a start tag and its contents to form a complete element. The process of replacing an element, attribute or entity with new data is called "decompression" because the result is often, but not always, larger than the original. Having an actor perform an action on an element is called "applying" the actor to the element. In addition, associating an entity name or attribute name with a value is referred to as "binding" to a name value. The value can be anything from one character to the entire document with markup. Processing the stream of input tokens (actor parsing, expansion and application) is called "evaluation" of the stream.

In the preferred embodiment described here, Inte
Since the syntax of the rForm® language is based on HTML derived from the SGML standard syntax, InForm
The terForm document can be parsed by an SGML parser with the appropriate document type definition (DTD). If the HTML editor considers non-standard entity and element tags, it will be able to process InterForm documents. SGML validator,
With the appropriate DTD, it can be used to verify the syntax structure of InterForm documents.

The two slightly different names (identifiers) are In.
Used in the terForm system. The first type of name is for element tags and attributes, and the second type of name is for entities. Element tag and attribute names are case-insensitive and have a single character (lett
er) and consists of any sequence of letters, numbers, “.” (period) and “-” (hyphen). Entity names use a similar character set, but are case-sensitive. If the name is URL (Uniform Reso
urce Locator) or a file name,
The character set and format of the name are determined by, for example, a set of external rules applicable to URLs or file names, and are not bound by the InterForm language.

Some actors, such as “if” actors and “set” actors, correspond directly to tags. By convention, actors that do not correspond directly to tags are represented by a dash ("
The name should start with-") and preferably end with a dash. The dash is also used to separate words in the actor's name. Check if it's inside “ag
As seen in "ent-running", the first word represents the name of the affected PIA data structure.

Many actors, such as the “get” actor, include “<get entity>” and “<getactor>”
Allows a wide variety of special attributes that modify behavior. There are many specialized actor versions with names such as "get.entity" where tags and attributes are separated by ".". The use of "." Is somewhat more efficient, although the amount of work required to determine the action that the ADI should take is small. In short, this "get" actor can specify a data structure.

An entity reference is defined as follows: Entity:: = '&' path 'i'? Path:: = identifier ['.' Path]? Identifier: = [letter | number | '-'] + That is, an entity reference is an ampersand ("
&"), Followed by the name, followed by a semicolon (";"). The semicolon is optional if characters that are not allowed in the name follow the entity name, In any case, it is a good practice to include a semicolon, which is important for entity names, which consist of several subnames separated by periods. (Agents, <table> or <dl> elements, forms, etc.) (similar to file paths).
If no namespace is given, ADI will:
A locally defined entity (eg, a list element element entity defined with a <repeat> tag),
Search the top-level (global) entity table associated with the active document to be interpreted. If the path ends in a namespace, that namespace is returned as a descriptive list or query string depending on the context.

By default, in addition to the entities shown in FIG.
Date, time, current agent, current PI
There is a variable to identify A and the current user.
Several namespaces are predefined as shown in FIG.

An element with only a start tag is called an "empty" element. Therefore, an empty element can be identified by its tag. In general, attributes and identifiers should not be separated by spaces. "
= ”.

In the advanced implementation, "entity-style hierarc
hical lookup on actor "tag is provided. This tag allows the <dl> list to function as an object. The order of the attributes in the start tag is preserved during processing, but the predefined actor And standard HT
It has no significant meaning for any of the ML tags.

Some actors process lists, such as the <repeat> actor described below. A list is a sequence of items, and is usually represented by an <li> element. Lists work very much like arrays in ordinary programming languages or collections in database languages. The following elements are treated as simple lists: <ul>, <o1>, <table>, <tr><table> is actually a list of lists. The description list (<dl>) can be treated as a two-element (<dt>, <dd>) list or a simple, flat list in which names and values are alternately arranged. Text strings,
In particular, attributes can be treated as a list by splitting with white space using the <split> actor. In short, any token sequence can be treated as a list by splitting on white space or token boundaries.

The active document can have association information. Depending on the association, the <dt> element and <tabl
e> elements are treated as being related by key = value. The table key is usually just the first item in the row, but a row with a blank first element (usually a <th> tag) is added to the previous row. Tables with labeled columns (typically indicated by a leading <th> element row) can be converted to an associated list.

Any character string in an appropriate format can be used as the association information. The pair is whitespace (as in the query string) or "
&"Character, but names and values are usually
= ”Character. Ordinary lists can also be used as association information by using <associate> actors to associate and pair items. Any element can be used as association information (of attributes and values). , Where tags and content are associated with special keys (usually "-tag-" and "-content-") as needed, but are not mistaken for attributes This is also <
associate> actor.

Each actor, at the time of its definition (after all, using elements inside the body of that actor),
An online document character string that can be recognized as an attribute as shown in FIG. FIG. 16 shows an example of an actor used to access an actor's document.

Here, a specific example of the above concept will be described with reference to FIGS. FIG.
(A) is a text portion 802 that instantiates an actor when it appears in a document. This text portion 802 is composed of a start tag 804, an instruction group 806, and an end tag 808.

The start tag 804 activates a certain actor (“demo” in this example), and
Define attributes and dscr attributes. Instruction group 806 is element 80
2 (FIG. 10A), and includes the definition of the "demo" actor. This set of instructions is for the “demo” actor “ha”
The instruction group 806 includes (<protect-result markup>) as shown in FIG.
It outputs the contents (with the </ protect-result> tag) without changing the marking, followed by the bold "=" and the result of expanding the contents.

FIG. 10B shows an input document 81 to be processed.
Indicates 0. When the ADI encounters the start tag <demo> during processing of the input document 810, it pushes the tag onto its parse stack as described above. <Demo>
Elements within the element are also pushed onto the parse stack until the end tag </ demo> is encountered, after which the <demo> element is expanded by calling its "handle" method.

In the case of the processing of the <demo> element, the definition of the same element is itself a <repeat> element.
Pushes the same on its input stack and returns the name "
process the definition content of the <demo> element by combining "content" with the content of the <demo> element. Processing continues from there. When processing the content of the <demo> element, the content is output. Then, the same contents are evaluated as described with reference to FIG.
Thus, an output document as shown in FIG. Since the content is a <repeat> element, the element is output without being changed first and then expanded. The <repeat> element has a list attribute “abc”, and the content of the <repeat> element is “&li;& li”, so the expansion result of “&li;&li;” is followed by a blank after the list item, and The list item is followed, so the expansion result of the <repeat> element is "a abbc c". Note the recursive nature of this expansion. It should also be noted that the documents in FIGS. 10A to 10C have the same format. For example, the output document shown in FIG. 10C can be passed as it is to the ADI as an input document.

FIGS. 10D and 10E illustrate another example of using the demo actor. FIG. 10D shows an input document having an <ol> (ordered list) element whose content is a reference to a list item. In the case of recursive expansion of these elements, "<li>&li;" is "<li>" followed by a list item with the value "abc" selected from the attributes of the <ol> element. Be expanded. These tokens are then processed as standard HTML markup to create the output document shown in FIG. FIG.
(E) indicates an ordered list of tokens found from the value of the list attribute.

FIG. 11 shows another embodiment or concept of the active document processor. The active document processor receives an input document 900 and provides it to an input parser 902, which is preferably the active document, but can be any parseable document. The input parser 902 converts the current node 906 (a) of the input document 900 into a node processor 904.
Connected to give to. Input processor 902
Is also connected to receive from the node processor 904 various commands described below. The node processor 904 is connected to the connection generator 912, and gives the current node 906 (a) or a node 906 (b) that is a processing result thereof together with an instruction group 910 for the processing. Upon receiving these nodes 906 (b), the output generator 912 receives the input document 900
Is output as the output document. This output can be sent to a string structure (string variables, fixed-length storage elements, etc.) or to a filter (pipe input,
Streaming input, etc.).

The node processor 904 has the input parser 9
02 is issued as follows. move to next sibling node (move to sibling node) move to first child node (move to first child node) move to parent node (move to parent node) tell whether a next sibling exists Judgment) tell whether a child exists (judgment of child) tell whether a parent exists (judgment of parent) get current node's type (get type of current node) get current node's tag (get tag of current node) get current node's atributes (get attributes of current node)

In response to the "move" command, the input parser 902 traverses the tree of the input document and outputs a new current node.
In response to the "ll" command or "get" command, the answer of the query is returned. With this parsing method, the input document does not have to be parsed in its entirety, so it can be of any size. You don't even need to create trees.

As is clear from the above description, the “move to next sibling” command and the “move to fi
By using the "rst child" command and the "move to parent" command, the entire document tree can be traversed even when only a part of the document is available.
FIG. 12 illustrates how a tree is constructed from a structured document. Referring to FIG. 12, "move right", "mo
You will come up with three move commands, "ve down" and "move up." If these commands are issued in the correct order, the node processor can receive all of the passed nodes. Even if the input is an endless (eg, streaming) input document, the entire document tree does not need to be stored in the local storage of the node processor.
As shown in FIG. 12, the structured document 900 can be converted into a parse tree having various elements appearing therein as nodes. In this example, the leaves of the parse tree are text elements of the input document 900.

Referring again to FIG. The instruction group 910 can include the following instructions. output node (output node) start (open) a new node (start a new node (open)) end a currently open node (end the currently open node) An output document in the same format as the document can be generated. Note that the architecture shown in FIG. 11 can accommodate output documents of the same format (subject to the same conditions and conventions), so that node processors can be nested or chained. For example, the output of one parser-processor-generator could be the input of another parser-processor-generator. This may be suitable where a single parser-processor-generator requires intermediate non-processing steps, such as storing the data structure of the active document after intermediate processing. If the input document represents a program, the program will be a program whose output is in the same format as itself.

The foregoing is illustrative and not intended to be limiting. From the above explanation,
Many modifications of the invention will be apparent to those skilled in the art. By way of example only, ADI uses a stand-alone format for simple document processing tasks and a PIA (personal information).
agency) takes both forms embedded in the system.
In the latter format, ADI is used for parsing and modifying documents retrieved from the Internet and other sources, and for generating documents for direct presentation to a user. A stand-alone ADI would be used, for example, to generate up-to-date documents and examples of its own actors and tag sets.

[0090]

As described in detail above, according to the present invention, an improved method and apparatus which can integrate a document and a behavior (program) associated therewith, which has been desired to be realized, are realized. It is possible. In particular, by combining active documents and agency systems, high-level functions can be implemented as active documents, so client and server software only need to support low-level functions, and are developed using the active document language. Is performed, a single unified language is used to specify the content (data) and processing (behavior) of the document, so that computer processing for the document can be easily implemented. An effect that can be described as an active document can be obtained.

[Brief description of the drawings]

FIG. 1 is a block diagram of a document system that uses different syntax for documents and programs.

FIG. 2 is a diagram showing the contents of a form 22 in FIG.

FIG. 3 is a diagram showing the contents of a CGI script in FIG. 1;

FIG. 4 is a block diagram of a personal information agency.

FIG. 5 is a diagram for explaining the operation of a personal information agency.

FIG. 6 is a diagram showing contents of an active document in FIG. 5;

FIG. 7 is a diagram showing an example of a browser display for user input.

FIG. 8 is a diagram showing an example of a browser display after user input.

FIG. 9 is a flowchart of a generalized active document interpretation process.

FIG. 10 is an explanatory diagram of an input / output document processed by an active document interpreter.

FIG. 11 is a block diagram of another embodiment according to the present invention.

FIG. 12 is an explanatory diagram of a parse tree generated for traversal by the input parser in FIG. 11;

FIG. 13 is an explanatory diagram of a local definition entity.

FIG. 14 is an explanatory diagram of a name space defined in advance.

FIG. 15 is an explanatory diagram of an attribute of an actor.

FIG. 16 is an explanatory diagram of an actor for document access.

[Explanation of symbols]

12 Browser (Client) 14 Server 20 Server Supervisor 22 Form 24 Script 400 PIA (Personal Information Agency) 401 Agent 402 Client (Browser) 404 Active Document

 ──────────────────────────────────────────────────続 き Continuing on the front page (72) Inventor Gregory Wolff United States 94025 Menlo Park Suite 115 Sand Hill Road 2882 Ricoh Corporation

Claims (19)

[Claims] 1. A method of processing an input structured document and generating an output document that is the result of the processing: a) Initializing a parser cursor to point to a first element of the input structured document. Initializing an input parser, b) coupling an element input of an element processor with the input parser to receive a current element from the input parser, and coupling an element output of the element processor to an output generator. Initializing the element processor; c) initializing a definition table coupled to the element processor; d) receiving an element sequence from the input parser and converting each element to the following steps 1) to 6). Processing by: 1) inputting an element from an element input of the element processor; 2) determining whether the element is an active element or a passive element. 3) if the element is a passive element, evaluate the passive element using an applicable definition obtained from the definition table and pass the result to the element output; 4) If the element is an active element, performing the following steps 1) and 2): i) combining the element output with an input of an active element queue; and ii) the applicability obtained from the definition table Evaluating the active element using any definition and passing the result to the element output; 5) coupling the element input to the output of the active element queue if the active element queue is not empty; And 6) if the active element queue is empty and the element input is not coupled to the input parser,
Combining the element input with the input parser; and e) generating the output document using the output generator. 2. The document processing method according to claim 1, wherein the output document is a null document when each processed element is evaluated as a null character string. 3. The document processing method according to claim 1, wherein the input structured document, the output document, and the definition table are each represented by a common structured document format. 4. The common structured document format is S
4. The document processing method according to claim 3, wherein the document is GML. 5. The step of determining whether the element is an active element or a passive element: a) comparing an element identifier with an active tag table; b) determining that a matching active tag is the active element. Identifying the element as an active element when found in the tag table; and c) determining that the matching active tag is the active tag.
2. The document processing method according to claim 1, further comprising the step of identifying the element as a passive element when the element is not found in the table. 6. The document processing method according to claim 5, wherein said comparing step is a step of comparing an element identifier with an active tag found in said definition table. 7. The step of evaluating the passive element includes: a) replacing tokens in the passive element with applicable definitions obtained from the definition table;
And b) evaluating the primitive expression, if any, in the passive element. 8. The step of evaluating the passive element includes: a) matching the element with a set of passive actor criteria; and b) matching when the element matches a criteria of a passive actor. 2. The document processing method according to claim 1, further comprising the step of: calling a passive actor method for each of the passive actors. 9. The processing of the active element comprises: a) replacing at least a passive token in the active element with an applicable definition obtained from the definition table; b) a primitive in the active element. 2. The document processing method according to claim 1, comprising: if there is an expression, evaluating the primitive expression; and c) calling an active actor action method with the active element as a parameter. 10. A method for processing an input structured document by an active document interpreter to generate an output document, comprising: a) parsing the input document to a sequence of elements including a start tag, an end tag, and an entity reference. B) performing the following steps 1) to 6) for each element encountered in said parse sequence: 1) The element is a passive element or an active element. Determining whether there is an active element, wherein the active element is an element with an associated handler in a handler database maintained by the active document interpreter; 2) a child element of the element is in the parse sequence 3) when the element is a passive element and has no child elements, Passing the passive element to the output process; 4) when the element is a passive element and has a child element, processing the child element by step b) and repeating the processing as necessary; 5) the element Is an active element and has child elements, processing the child elements by the following steps i) and ii): i) processing the child elements according to step b), and performing the processing as necessary Iterating; and ii) step a) sending the element output in 5) i to a storage queue; and 6) if the storage queue is not empty, the input analyzed until the storage queue is empty. Using the storage queue as a source of the parse sequence instead of a document; and c) defining in the output process each element output to the output process as a defined output. Document processing method characterized by comprising the steps, processes according to the rules set. 11. The method of providing the passive element to the output process further comprising: a) determining whether an entity reference for the passive element is defined in an entity definition set; and b) determining whether the entity reference is 11. The document processing method according to claim 10, further comprising, when being defined in the entity definition set, outputting a corresponding entity value of the defined entity reference. 12. Steps a), b) and c) are performed substantially simultaneously so that the input structured document can be at least partially processed without reference to the entire input structured document. 11. The document processing method according to claim 10, wherein: 13. The document processing method according to claim 10, wherein steps a), b) and c) are performed sequentially. 14. The document processing method according to claim 10, wherein the processing operations of steps a), b) and c) are expressed in the same syntax as the input structured document. 15. The document processing method according to claim 10, wherein the handler database is expressed by the same syntax as the input structured document. 16. An apparatus for processing an input structured document represented by a parse tree and generating an output document, comprising: a) an input document tree that traverses the parse tree and outputs a current element when requested. A traverser, wherein the current element is a cursor-pointed element in the parse tree; b) an element processor coupled to the input document tree traverser for processing an element output by the input document tree traverser. C) an output document tree constructor combined with the element processor for building an output document tree with the elements output by the element processor; d) determining whether the input element is an active element or a passive element For the first within the element processor
E) a first router inside the element processor for sending a passive element to an output stage of the element processor and an active element to an element queue; f) a corresponding entity replacement value for the input element A) a second element evaluator inside said element processor to find out from the definition table; and g) sending an element from said element queue to said second element evaluator and output of said element processor when said element queue is not empty; A document processing apparatus, comprising: a second router inside the element processor for sending an element from the input to the element processor when the element processor is empty. 17. A method of processing an input document to obtain an output document, comprising: a) parsing the input document to obtain a sequence consisting of an element start tag, an element end tag, an entity reference, and a character string; b) replaces the input document with 1) each defined entity reference with a sequence of instructions that, when executed, outputs a defined replacement value; 2) each element identified as an active element, when executed, Take the output of the instruction corresponding to the attribute and content of the element as input, replace it with the instruction sequence passed from the definition of the active element to the instruction sequence derived by this method, 3) Recognize that it represents a primitive operation When each element executed is executed, it takes in the output of the instruction corresponding to the attribute and content of the element as input, and instructs them. By replacing the unrecognized element start tag, element end tag, entity reference, and character string with an instruction sequence that outputs it. Converting the sequence into a sequence: and c) executing the obtained instruction sequence to generate an output document. 18. A computer-readable storage for recording a program for causing a computer to execute the processing for the document processing method according to claim 1. Description: Medium. 19. A computer-readable storage medium having recorded thereon a program for causing a computer to realize the functions of the document processing apparatus according to claim 16.