Method and apparatus for providing an applications development system for internet based applications

[0002] This invention relates generally to computer program applications and more particularly to providing a method of providing an application development environment using the hypertext markup language (HTML).

[0003] As is known in the art, one type of interface by which a user may access information over the intemet or an intranet is a so called web browser. A web browser typically provides a graphical interface and allows a user navigate or “browse” the internet using a hypertext information and communication system (i.e. the world wide web). One such well known browser is the Netscape browser developed by Netscape Communications Corporation. Thus, any computer with a network connection to the internet may potentially be accessed by a user with a computer also connected to the internet and running a web browser.

[0004] The proliferation of use of the internet, and its cousins intranets and extranets, has led to the development of more sophisticated “web” based applications. That is, applications are being developed which utilize the industry standard browsers to provide a user interface to sophisticated applications. One example of an internet based application is the storage system management application described in a patent application entitled “Non-hierarchical Application Interface for HTML-based Network Storage Management Programs”, by Osmond, et al., application Ser. No. 08/775,034, filed on Dec. 30, 1996 and assigned to the assignee of the present application.

[0005] As is known in the art, application programs which are developed using high level programming languages (e.g. the C programming language) are often written in a modular fashion. That is, a large application will generally be broken down into smaller applications, functions, or modules which may be compiled separately and are thus easier to manage during development and debug. After compilation, the many object files corresponding to the source language modules are then linked together to provide a single executable file (i.e. the application).

[0006] One problem associated with developing application programs, especially large scale application programs, is the need for the developer to be consistent when using constants. Another problem arises from the need to develop portable programs which may be used on computers with different operating systems. In the “C” programming language, these problems are addressed by the so called “C-preprocessor”. The C-preprocessor is an integral part of the C compiler and provides a way for developers to define constants, both positively and conditionally, in order to provide consistency and portability. The C-preprocessor is described in detail in Stephen G. Kochran, “Programming in C”, Indianapolis, Ind.: Hayden Books, 1987. In general, the C-preprocessor provides a set of special commands that allow developers to assign names to constants that may then be used throughout the program to refer to the constant. The naming of constants may be done conditionally as well as absolutely.

[0007] The HTML language is basically a set of instructions which are used to create an ASCII text document. The instructions, when read by a browser, define how a particular screen or “page” will look when displayed by the browser. By nature, HTML does not provide a rich programming environment like C or other high level programming languages provide. Thus, development and maintenance of web-based applications can become unwieldy. Consider an application that has several dozen different screens or pages which provide the user interface. Then consider the same interface being adapted to variants of the same application. In order to change a constant value or a file pointer (e.g. URL address) for the applications, it may be necessary to individually edit dozens of files individually. Thus the probability for error becomes greater and as such development times increase dramatically. It would be advantageous therefore to provide a development environment for web-based application interfaces which have the richness of typical high level applications programs.

[0008] In accordance with the present invention, a method for developing internet applications with a markup language includes the steps of defining a set of commands in addition to standard markup language instructions. The commands are then imbedded in a first file having said standard markup language instructions. The resulting file is then fed into a preprocessor. The preprocessor reads, on a line by line basis, the contents of the first file. If one of the lines read by said preprocessor includes one of the predefined commands, proscribed steps are taken by the preprocessor with the result of those steps ultimately producing an output which is written to an output file. If the lines read by the preprocessor are standard markup language instructions having none of the predefined commands the lines are written to the output file without modification.

[0009] The above and further advantages of the present invention may be better understood by referring to the following description taken in conjunction with the accompanying drawings in which:

[0010] FIG. 1A is a flowchart depicting the overall operation of the preprocessor of the present invention; and

[0011] FIGS. 1B-1E are flowcharts depicting the actions of preprocessor in response to various preprocessor commands encountered in a source file.

[0012] In accordance with the present invention, an applications development environment for developing hypertext markup language (HTML) based programs was provided. In order to provide the applications development environment, an HTML preprocessor was developed and a set of preprocessor commands created and defined. The commands are generally non-HTML commands which are imbedded in a source HTML file. When interpreted by the preprocessor, the commands cause an output HTML file which includes all of the original HTML command as well as any substitutions and/or inclusions defined by the preprocessor commands.

[0013] According to a preferred embodiment of the present invention, a number of commands are included in the set of preprocessor commands which, as will be discussed in detail below, are interpreted by the preprocessor in order to provide the required preprocessing functionality. Exemplary commands within the set of preprocessor commands of the present invention include, among others, an “include” command, a “define” command, a “replace” command, as well as a set of conditional commands used to conditionally perform a substation or inclusion.

[0014] According to the preferred embodiment, the syntax for the “include” command is as follows <INCL “file name”>. As suggested by the syntax, the INCL preprocessor command is used to direct the preprocessor to include the entire contents of the file, indicated by “file name”, into the location of the source HTML file where the include command appears. An example of the use of the INCLUDE preprocessor command is as follows:

[0015] <FORM NAME=‘some_name’>

[0016] <INPUT TYPE=‘text’NAME=‘some_text’>

[0017] <INCL “a_file_containing_another_input_element”>

[0018] <INPUT TYPE=‘submit’VALUE=‘Press This’>

[0019] </FORM>

[0020] In this example, a form is being defined in the HTML source file. As will be described in more detail below, whatever text is contained within the included file is written to the output HTML file. If there are any preprocessor commands in the included file, they are processed in line. This permits nested “includes” and conditional “includes”, as well as included conditionals.

[0021] Also according to the preferred embodiment of the present invention, the syntax for the “define” preprocessor command appears as follows: <DEFN tag expression>. The DEFN preprocessor command of the present invention is used in conjunction with the “replace” (REPL) preprocessor command to establish a consistent constant name for either a value or an expression. Thus the preprocessor, when it encounters a DEFN preprocessor command, stores the values of the tag and the expression in local memory. During subsequent processing, anywhere in the source HTML file where a REPL command is encountered, the preprocessor will replace the tag with the expression as previously defined. The replace preprocessor command of the present inventions has a syntax as follows: <REPL tag>. An example of the use of the DEFN and REPL commands is shown below:

[0022] <DEFN My_button_image “<IMG SRC=‘ac.gif’ HEIGHT=32 WIDTH=80>”>

[0023] <A><HREF=javascript:do_something( )><REPL My_button_image></A>

[0024] The generated code included in the output file would then look as follows:

[0025] <A><HREF=javascript:do_something( )><IMG SRC=‘ac.gif’ HEIGHT=32 WIDTH=80></A>

[0026] One way to manage a large application program may be to make several or even hundreds of definitions and place all the DEFN commands within a separate file. The definitions in the separate file may then included, via the INCL preprocessor command, into the source HTML file as described above. Thus it can be seen that management of constants or constant expressions may be done in a single place and then included within several files of an application program.

[0027] In addition to the commands described above, the preprocessor of the present invention also supports a set of conditional expressions which allow the above three commands to be used in conjunction with an evaluated conditional expression to either include files, define tags, or replace tags or generally cause and output to the destination file depending on the conditional expression. According to the preferred embodiment, the conditional expressions include IFDEF, ENDIF, IFNDEF. The syntax for the conditional expressions may have several combinations an example of which is shown below:

[0028] <IFDEF SNMS>

[0029] <H2>Welcome to SNMS</H2>

[0030] <ELSE>

[0031] <IFDEF SNFS>

[0032] <H2>Welcome to SNFS</H2>

[0033] <ELSE>

[0034] <H2>Welcome to SNBR</H2>

[0035] <ENDIF>

[0036] <ENDIF>

[0037] In the above example, different welcome messages are placed in the output HTML file by the preprocessor depending on which of the constants SNMS, SNFS, SNBR have previously been defined. In addition to the straightforward example shown above, rather than simply provide a particular item to the output file when a condition is true, other preprocessor commands may be evaluated when a condition is met as shown in the following example:

[0038] <IFDEF SNMS>

[0039] <INCL snms.hts>

[0040] <H2>Welcome to SNMS</H2>

[0041] <ELSE>

[0042] <IFDEF SNFS>

[0043] <INCL snfs.hts>

[0044] <H2>Welcome to SNFS</H2>

[0045] <ELSE>

[0046] <H2>Welcome to SNBR</H2>

[0047] <INCL snbr.hts>

[0048] <ENDIF>

[0049] <ENDIF>

[0050] Here, the file snms.hts may have all the appropriate definitions and replace commands to create the appropriate HTML code for producing the SNMS display page. It can be seen then that with the conditional expressions evaluated by the preprocessor, other preprocessor commands may be executed depending on previously defined tags or constants or other values which are available by the time the preprocessor reaches the conditional expression.

[0051] Although a select few commands were described above, it should be understood that the commands described above were for illustration purposes only. Other commands may also be provided which enable an applications developer programming an interface using an HTML language to provide a rich programming environment similar to those of the high level programming languages.

[0052] The operation of the preprocessor of the present invention will now be discussed in connection with FIGS. 1A through 1E. Referring first to FIG. 1A, a flow chart 10 is shown which depicts the generalized operation of the preprocessor of the present invention. Use of the preprocessor of the present invention assumes that the preprocessor commands defined above have been embedded along with HTML instructions in a source file (HTS) as described above. Operation of preprocessor of the present invention starts at step 100 with the loading of the preprocessor program into a computer memory and providing on the command line, the name of the input source file (e.g. source .hts). At step 110, the source HTS file which has been identified to the preprocessor is open for reading. At the same time, an output HTML file is open for writing. In order to distinguish the source file including the preprocessor commands and the output file including the substitutions and the operations performed by the preprocessor, the preferred embodiment of the present invention expects that an input file will have the extension .hts while the output file created by the preprocessor will have the extension .htm (as is conventional for files read by a browser). Once the input and output files are open, processing on the input file begins at step 120 where the first line of the input file is read. At step 130 an evaluation is performed on the input line to determine whether that line includes one of the previously described preprocessor commands. If one of the previously defined preprocessor commands is contained within the line read by the preprocessor, processing moves to step 200 of the flow chart.

[0053] Each of the evaluation steps 200, 300, 400, and 500 of flow chart 10 is used to identify the particular preprocessor command encountered in the input line. Thus, for example, if at step 200 the preprocessor has identified the include preprocessor command a series of steps will be taken by the preprocessor as will be discussed below in connection with FIG. 1B. Similarly, the evaluation steps 300, 400, and 500 identify the other pre-defined preprocessor commands with the appropriate actions taken in as described in FIGS. 1C, 1D, and 1E respectively. After execution of the particular steps associated with the respective preprocessor commands the process returns to step 170 of flow chart 10. At step 170, a test is performed to determine whether the end of the input line has been reached. If the end of the input line has not been reached, processing returns to step 130 where the input line is read analyzed further. Alternately, if the end of an input line has been reached, processing proceeds to step 175 where an end of file test is performed. If the end of the input file has not been reached, processing returns to step 120 with another input line being read from the source HTS file.

[0054] If at step 130, instead of encountering a preprocessor command as described above, the line read from the input file does not contain a preprocessor command, processing simply moves to step 160 with the input line being written as an output line to the HTML output file. From step 160 processing continues to step 175 where an end-of-file condition is checked. If the end of the input file has not been reached, then processing end moves back to step 120. If, however, the end of the input file has been reached processing moves to step 180 where both the input source file and the output HTML file are closed. The process then moves to step 190 where the preprocessing function ends.

[0055] Referring now to FIG. 1B, flow chart 20 depicts the steps performed by the preprocessor of the present invention when an input file line has been evaluated to include the INCL preprocessor command as determined by step 200 of flow chart 10 (FIG. 1B). At step 210 of flow chart 20, the file identified with the file name attribute of the include preprocessor command is opened by the preprocessor for reading. If the file can not be opened, an error report may be generated to the user. As with the source HTS file, the file identified to be included in the output HTML file will be subject to the process of flow chart 10 of FIG. 1A. That is, each of the lines of the file to be included evaluated by the preprocessor as if it were a source file. As each line of the include file is evaluated, the contents of the file or the appropriate substitutions are inserted into the output HTML file until the end of file of the include file has been reached. At step 240, the file to be included is closed with the process returning to step 170 of flow chart 10 (FIG. 1A).

[0056] Referring now to FIG. 1C, flowchart 30 depicts the steps taken by the preprocessor of the present invention when a “DEFN” or define command is encountered in the source .hts file. In response to reading a source line containing a DEFN command, the preprocessor will first, at step 310, create temporary storage space for both the tag and expression portion of the define command. The tag and expression are then stored in the temporary storage at step 320. Finally, at step 330, a link is created between the stored tag and expression. The link may actually be a result of the manner in which the tag and expression are stored. That is, they may be stored in a two by X dimensional array. The tag and expression would then be stored at the same index into the array with an offset from the index used to store or retrieve the expression. The link is necessary to furnish the correct expression when the tag is later encountered in connection with the REPL command.

[0057] Referring now to FIG. 1D, flowchart 40 depicts the steps taken by the preprocessor of the present invention when a “REPL” or define command is encountered in the source .hts file. In response to reading a source line containing a REPL command, the preprocessor will first, at step 410 scan the temporary storage to find the tag specified in the REPL command. Once the tag is found, the preprocessor then finds the expression associated with the specified tag, at step 420. Then, at step 430, the preprocessor writes the associated expression to the output HTML (i.e. the file having the .htm extension) file at the place where the REPL command resided in the input file. Processing then returns to step 170 (FIG. 1). Of course, if the specified tag were not found in the temporary storage, an error report or some other action would most likely occur.

[0058] Referring now to FIG. 1E, the steps taken by the preprocessor of the present invention when upon encountering an IFDEF conditional command are depicted by flowchart 50. First, at step 502, the preprocessor will evaluate the conditional statement read from the source HTS file. IF the condition is true, as determined at step 504, the preprocessor will get the immediately following input line from the source HTS file (step 506). At step 508, that input line is evaluated to determine if it contains one of the preprocessor commands. If it does, the preprocessor command is evaluated as depicted in steps 512-518 and operates as described above with reference to FIG. 1A. If the input line retrieved at step 506 does not contain a preprocessor command, the line is written to the output HTML file as indicated in step 510. At this point processing continues at step 506 with the retrieval of another input line. Alternately, if the line retrieved at step 506 is another preprocessor command, it will be evaluated according to steps 512-516. If the command is an ENDIF conditional command as determined at step 518, the process returns to step 170 (FIG. 1A) as indicated by step 511.

[0059] It can be seen then that the preprocessor of the present invention provides a powerful applications development environment for developing RTML based applications. It will be apparent to those of skill in the art that other preprocessor commands may be employed to provide differing functionality without departing from the underlying concept of centralized applications development and management.

[0060] Having described a preferred embodiment of the present invention it will now become apparent to those of skill in the art that other embodiments incorporating its concepts may be provided. It is felt therefore, that this invention should not be limited to the disclosed embodiment but rather should be limited only by the spirit and scope of the appended claims.