JP3698976B2 - Command line generator - Google Patents

Description

【００４８】
スクリプトNo.２のライン１はテキストストリング「tcl」および「expect」を含む。このどちらかは、スクリプト言語はＴＣＬであると識別する。再び、このテキストストリングは図３Ａのステップ３０４によりシーク(seek)される。
【００４９】
スクリプトNo.２のライン２乃至ライン４は使用されている未定義変数を列挙する。ライン３およびライン４は変数識別テキストストリングの後にテキストストリングを含んでいることを注意されたい。このように、プロセッサ４０２はステップ３２２からステップ３２４に向かい、後続するテキストストリングを用いてユーザ入力を促す。これに対し、ライン２はプロセッサ４０２をステップ３２２からステップ３２６に向かわせ、以下に列挙したルックアップテーブルのテキストストリングを使用してユーザ入力を促す。
【００５０】
スクリプトNo.２を実行するコマンドライン（「sendmail」と名付けられている）は、sendmail.tcl recipients filename subject-indicating-textとなる。ここで、引数の順序は非常に重要である。もし不慣れなユーザが未定義変数を判断する場合には、付加引数に対する順序で推測を行わなくてはならない。３つの引数の順序には６つの置換が考えられる。すなわち、要求されるコマンドラインにおいて６つの試みが可能である。本発明によるコマンドラインジェネレータは、コマンドラインにおける引数として変数の値を付加する順序だけでなく、スクリプトの未定義変数を識別あるいは思い出さなくてはならないという負担をユーザから取り除く。
【００５１】
ユーザに変数の値を入力するよう指示を出す際に、スクリプトNo.１とスクリプトNo.２の例のどちらかで使用されるスクリプト言語とテキストストリングの全変数を記憶する変数ルックアップテーブルの例を以下に記載する。
変数ルックアップテーブル(Ｌook Ｕp Ｔable：ＬＵＴ）
変数名 プロンプトストリング
ACCOUNT Please Enter The Customer Account Number
CUSTOMER Please Enter The Customer's Full Name
FILENAME Please Enter A File Name
RECIPIENTS Please Enter The File Name With The List Of Recipients
SUBJECT Please Enter A Subject Matter
本発明によるコマンドラインジェネレータは、変数セットをあらかじめ限定出来るあらゆるスクリプト言語による使用に適する。上記例はUNIX（登録商標） Kornシェルスクリプト言語およびツールコマンド言語に基づくものであり、また、本発明はWAMILスクリプト言語に特に適するものであるが、上述のように他のスクリプト言語にも適合する。
【００５２】
スクリプトは本発明によるコマンドラインジェネレータによって書かれることを意図する。このようなスクリプトにおいては使用されている未定義変数を識別する非実行ラインをまず最初に有する。そのような各非実行ラインはおそらく１つだけ変数名テキストストリングを含むであろう。しかし、既存のスクリプトにおいてはそのような非実行ラインをスクリプトのトップに挿入する修正も非常に簡単に出来る。このようにほんの少しの努力で既存スクリプトをユーザフレンドリにすることが可能である。
【００５３】
本発明によるコマンドラインジェネレータの長所は、コマンドラインに付加される引数としてこれら変数の値が提示されるべきフォーマットだけでなく、スクリプト内で使用されている未定義変数が何であるかを思い出さなくてはならない苦労からユーザを解放することである。このように、本発明は熟達したユーザ向けのスクリプトに関して、不慣れなユーザでもこのようなスクリプトが（実際的な方法で）使用出来るようにする。これに反して、従来技術においては不慣れなユーザがこのようなスクリプトを使用することを事実上不可能にしている。さらに、スクリプトライタが不慣れなユーザによる使用を考慮する場合、スクリプトライタはもはやマルチプル専用インタフェース部分をスクリプト内に挿入する必要がなくなる。スクリプトライタは本発明によるコマンドラインジェネレータの有用性に頼ることが出来るため、未定義変数を識別するコメントラインを（望ましくはスクリプトの初めに）挿入するだけでよい。
【００５４】
以上、本発明の実施例を詳細に説明したが、同じようなものが様々な方法で実現可能である。このようなバリエーションは本願発明の精神と範囲から発展するものとして考慮しなければならない。本発明の範囲を逸脱することなく他の方法でも具体化出来ることは当業者にとって明らかである。
【図面の簡単な説明】
【図１】従来技術によるコマンドライン実行図である。
【図２】本発明によるコマンドライン生成の図である。
【図３Ａ】本発明によるコマンドライン生成の実施例におけるステップを示したフローチャートである。
【図３Ｂ】本発明によるコマンドライン生成の具体的実施例におけるステップを示したフローチャートである。
【図４】本発明によるコマンドライン生成を実行するハードウェアのブロック図である。[0001]
FIELD OF THE INVENTION
The present invention is directed to the field of command line execution of scripts. More particularly, it relates to a technique for generating a complete command line required to execute a script. More specifically, the present invention relates to a technique for causing a user to input a value of an undefined variable in a script and generating a complete command line necessary for executing the script.
[0002]
BACKGROUND OF THE INVENTION
A script is a sequence of commands or a program that is decoded or executed by another program. In contrast, a compiled program is a sequence of commands that have been converted to processor machine code for direct execution by the processor. In general, scripts are easier and faster on code than compiled programs.
[0003]
Scripts are generally run from the command line. The user enters the script name and arguments passed to the script. Such arguments often represent undefined variables in the script. Undefined variables are most commonly in the form of arguments added to the command line, whose values are supplied to the script at runtime.
[0004]
FIG. 1 is a diagram of command line execution 100 according to the prior art. Block 102 shows all command lines generated manually and entered into the script language interpreter 104 by the user. Furthermore, the user is burdened not only with the format required to pass the value of the undefined variable as an argument added to the command line, but also with the undefined variable in the script.
[0005]
Alternatively, you can create a script that prompts the user to enter all undefined variables. However, a dedicated user interface part added to the script is required, which is very complicated and long. Furthermore, such a dedicated user interface portion is limited to use only by users who are familiar with scripts. Because he knows the undefined variables in the script and knows what needs to be passed as arguments on the command line as well as the format of these arguments. The dedicated user interface part slows down the script execution speed.
[0006]
For experienced users, the command line interface is a very flexible tool for executing scripts. Also, rather than having a dedicated user interface part in the script, the script is easier to write, shorter, by putting the burden of remembering and entering undefined variables, not just other arguments, And it can run faster.
[0007]
However, in this conventional command line generation, for an unfamiliar user, command line execution may be frustrating for some people or a total barrier for others. . In general, unfamiliar users are not familiar with undefined variables used in scripts, and if you become aware of these variables for any reason, you are familiar with the format in which you should enter the values for these variables on the command line. There are many cases that are not. As a result, unfamiliar users will suffer from trial and error over and over to complete the command line. Also, there are even cases where the command cannot be made accurately.
[0008]
SUMMARY OF THE INVENTION
In order to solve the above-described problems, the present invention recognizes, in part, a problem that many inexperienced users desire to use scripts intended for users who are proficient in command line execution.
[0009]
The present invention also provides, in part, a method (and corresponding software and apparatus) for generating a script command line. In such a command line generation, an inexperienced user is instructed to enter the values of all undefined variables in the script and, like other required arguments, variables that should be added as required form arguments. Generate a command line with all necessary values.
[0010]
The present invention also provides, in part, a script command line execution method (related software and apparatus). The script contains at least one undefined variable whose value is intended to be entered by the user as an argument on the command line when the script is executed. This method provides (a) a script, (b) finds an instance in an undefined variable script that is intended to be entered by the user as an argument on the command line, and (c) gives the user , Instructing to input the value of at least one undefined variable, and (d) generating a complete command line with arguments corresponding to the values obtained in step (c).
[0011]
The present invention also provides, in part, a script command line execution method (related software and apparatus). The script contains at least one undefined variable whose value is intended to be entered by the user as an argument on the command line when the script is executed. This method provides (a) a script, (b) treats the first line of the script as a text sring, and (c) an undefined that is intended to be entered by the user as a command line argument. Search all substring strings corresponding to the variable, (d) instruct the user to enter the value of at least one corresponding undefined variable, and (e) receive from the user in step (d) Store at least one value, (f) repeat steps (b) through (e) for the remaining lines of the script, (g) for scripts with arguments corresponding to the values stored in step (e) Consists of generating a complete command line.
[0012]
These and other objects of the present invention will become more apparent from the following detailed description. However, it will be apparent to those skilled in the art that other methods can be implemented without departing from the scope of the invention.
[0013]
Detailed Description of the Invention
FIG. 2 is a block diagram of a script line generation 200 according to the present invention. Block 202 represents a script. Remember that the script is a text file. Such a script can be generated by a graphical user interface (GUI) scripter 204 or a text editor 206.
[0014]
Once generated, the script 202 can be accessed by the command line generator 208. Command line generator 208 instructs the user to enter the value of the undefined variable in the script through display device 210. The user communicates the value of the undefined variable through the manual input device 212. The output of the command line generator 208 is a complete command line that is passed to the script language interpreter 104.
[0015]
  The command line generator 208 according to the present invention is preferably implemented as shown in the example of FIG. That is, in FIG. 4, a processor 402, a video display device (VDD) 406 (corresponding to 210 in FIG. 2), a user input device 408 such as a mouse or keyboard (corresponding to the device 212 in FIG. 2), and a memory It takes the form of a program system 400 with a device 404. The memory 404 stores one or more programs or scripts that cause the processor 402 to generate a command line generator according to the present invention. For example, in the embodiment of the present invention, it is written using a tool command language (TCL). The computer readable memory 404 can be RAM, ROM, fixed hard disk drive, or floppy.(Registered trademark)A removable storage medium for a non-fixed disk drive such as a disk or CDROM can be provided. A program that causes processor 402 to generate a command line generator according to the present invention can be downloaded from remote host 410 to processor 402 over any connection 412. When the program is downloaded through the optional connection 412, the computer readable medium in which the program is implemented takes the form of a propagated signal.
[0016]
The generation of a command line generator according to the present invention involves not only access to a lookup table, but also a number of storage operations and comparison operations. As such, the processor 402 must have sufficient processing power to reasonably and reliably deliver high speed results. An example of a processor that meets these requirements is the Pentium family marketed by Intel Inc.
[0017]
The processor 402 executes the program of the interpreter 104 as well as the command line generator 208. Further, the processor 402 also executes a program of the GUI scripter 204 or the text editor 206.
[0018]
The command line generator according to the invention can be adapted to a very large number of languages. Particularly well suited is the Wireless Automation Manager Interface Language (WAMIL), which is the name of the invention of the co-pending application.
[0019]
As the language name suggests, WAMIL is a better fit for wireless technology. For the purpose of ascertaining the exact context of WAMIL and the exact context in use of the command line generation technique according to the present invention in the context of WAMIL scripts, a brief description of wireless technology will now be provided.
[0020]
A wireless communication network is an example of a large-scale system. Large scale systems often include a monitoring system that allows one or more users to generally monitor system performance, and in particular to monitor one or more parameter conditions of the large scale system. In many cases, the method of distributing information to the user by the monitoring system is a burden.
[0021]
The wireless communication network provides wireless communication services to wireless units in a geographical area. A Mobile Switching Center (MSC) is responsible for, among other things, establishing and maintaining calls between wireless devices and calls between wireless devices and wired devices. In this way, the mobile switching center interconnects wireless devices in a geographical area and a public switched telephone network (PSTN). The geographical area served by the mobile switching center is divided into different areas in space called “cells”. In the block diagram, each cell is schematically represented by one hexagon in a honeycomb pattern. However, in actuality, each cell has an irregular shape due to the topology of the terrain surrounding the cell. Generally, a base station is arranged in each cell, and includes a radio station (radio) and an antenna used when the base station communicates with a radio apparatus in the cell. The base station also includes a transmission device that is used when the base station communicates with a mobile switching center in a geographical area through a communication link. Sometimes one cell site covers multiple sectors. Here, it is possible to paraphrase a cell and a sector.
[0022]
In a mobile radio communication system, a base station and a radio apparatus perform voice communication or data communication through a forward link and a reverse link. The forward link carries communication signals from the base station to the wireless device via at least one forward channel. The reverse link also carries communication signals from the wireless device to the base station via at least one reverse channel. There are many plans for determining how to communicate between a wireless device and a base station in a mobile communication system. For example, a wireless communication link between a wireless device and a base station includes time division multiple access (TDMA), frequency division multiple access (FDMA), code division multiple access (Code-Division). It can be defined based on different radio protocols including Multiple Access (CDMA).
[0023]
When a wireless device moves between cells within a geographic area, the mobile switching center exchanges calls between base stations, called handoffs, in real time. Currently, in FDMA, TDMA, CDMA, and GSM, cell site planning for determining the geographical coverage of a cell is a manual and intensive task that requires constant adjustment. In cell planning, a geographic area topology and a suitable antenna site are selected based on effectiveness and zoning rules. In general, such a choice is acceptable if not optimal. Next, a drive test and manual collection of signal data are performed, especially around the coverage area. Next, the transmission / reception antenna and power transmission are adjusted by manual interaction method to improve call quality. Occasionally, the frequency is swapped with neighboring cells and / or the transmit power is readjusted to improve coverage. Overtime, cell site engineers reconfirm customer complaints and cell site dropped call reports and attempt to optimize RF performance manually.
[0024]
Lucent Technologies, Inc. has developed a monitoring system that can be used when a user changes the parameters of the wireless communication system, as well as extracting data about the parameters of the wireless communication system. The monitoring system can generate a TIpdunix (TI) interface, a Status Display Page (SDP) interface, or an AUTOPLEX Recent Change & Verification Database (APXRCV) interface. These interfaces can be used individually. However, information extracted from one of the interfaces is typically used in making a decision to use the second interface in some way from among the interfaces. When using the interface, the user must initiate a discrete process. In a Windows-based environment, each interface session has its own window.
[0025]
Scripts related to wireless technology generally include variables corresponding to the parameters of the wireless communication network. Some examples of such a large number of variables are MSC (Mobile Switching Center), CELL (number of cells), ANT (antenna), CAT (clock and tone board number variable), There are CCC (CDMA clustor controller number), CCU (CDMA channel unit number), and CE (channel element number).
[0026]
The WAMIL language includes commands, if-construct elements, and while-construct elements. The WAMIL command has a format of “interface: command” such as “TI: OP: CELL ARGUMENT”, “WAM: CONNECT SDP”, or “WAM: GETSDP”. In other words, the WAMIL command has a first field that identifies the interface and a second field that identifies the command. In fact, the first field identifies the interface in which the command in the second field is valid. Preferably, the first field precedes the second field, or the first field is the header of the second field and is separated by an alphabetic character such as a colon.
[0027]
The WAMIL language is described in detail in Gaspar Hernandez, III's Lucent Technologies application entitled "Multiple Interface Scripting Language".
One of the commands is a “GETSDP” command. For this command,
Gaspar Hernandez, III's Lucent Technologies application entitled “Technology to Translate Non-Text Display Generation Data Representing An Indicator Into Text Variables” It is stated.
The preferred context for using scripts written in the WAMIL language is described in detail in the Lucent Technologies application entitled “Liaison Interface” by Gaspar Hernandez, III.
Details of the scripters and interpreters that better fit the WAMIL language are described in detail in Gaspar Hernandez, III's Lucent Technologies application entitled "Scriptor and Interpreter".
[0028]
3A and 3B are flowcharts illustrating steps in a specific example of command line generation according to the present invention. This flowchart starts from step 300. For example, a user may click on the processor 402 text-based operating system command line or by clicking on the processor 402 window-based operating system icon. It will execute the command generator. In a text-based operating system, the command line generation program 208 instructs the user to enter the value of an undefined variable by displaying a text string on the display device 406. In a Windows-based environment, the processor 402 generates a dialog box (or window) and prompts the user to enter values for undefined variables.
[0029]
When the command line generation program is started in step 300, the process proceeds to step 302 where a script is provided. In a text-based environment, the script name is provided on the command line as an argument. In a window-based environment, the user clicks on the program name when it appears in the list.
[0030]
When the script is provided, the process proceeds to step 304 where the script language is identified. The command line generator request is to have a text string that identifies the scripting language embedded in the script. This identifier is preferably embedded in the beginning of the script in a non-executable comment format. The script name preferably has an extension that identifies the script language, such that a Korn shell script has an extension “.ksh” such as “script.ksh”.
[0031]
For all script languages supported by the command line generator, there is a script language lookup table in memory 404 that lists all such script languages. In addition, the memory 404 also has a lookup table that includes all variables for all script languages. The command line generator must first determine the script language identification for accurate command execution.
[0032]
In step 306, the processor 402 retrieves the first line of the script under consideration and the first line of the script language lookup table. It then determines whether the language is supported. The processor 402 preferably first compares the script language lookup table entry with the filename extension. Next, if necessary, processor 402 compares the script language lookup table entry with the text substring of the first line of the script. The processor 402 performs this comparison process until it matches or until all entries in the script language lookup table are fully covered. If all entries are fully covered, it returns an error prompt indicating that the script is written in a language not supported by the command line generator.
[0033]
If there is a match, that is, if a script language is identified in step 304, the processor 402 uses a variable lookup table with variables for all script languages.
[0034]
The flowchart of FIG. 3A proceeds from step 304 to step 308, where processor 402 obtains the current (here, next) line in the script. In the next step 310, the processor 402 treats the script line under consideration as a text string. At step 312, processor 402 accesses a variable lookup table in memory 404 to retrieve the first variable string. Next, in step 314, the processor 402 compares the substring of the script line under consideration with the variable string.
[0035]
In the next determination step 316, it is determined whether or not they match. If not, proceed to decision step 318 to determine if the current variable is the last variable in the lookup table. If not, at step 320, processor 402 sets the next variable in the lookup table to the current variable. The flowchart step returns from step 320 to step 312 to retrieve the current variable (ie, the next variable).
[0036]
If there is a match at step 316, the process proceeds to decision step 322 where the processor 402 determines whether there is a substring following the substring that matched the command string. If not, the processor 402 prompts the user by using a text string from a lookup table that is indexed to the current variable. If there are substrings in the script line after the matching substring, proceed to step 324 where processor 402 uses these additional substrings in the script line as prompt strings to be displayed to the user to define undefined variables. Instruct the user to enter the value of.
[0037]
The steps in the flowchart proceed from step 324 and step 326 in FIG. 3A to step 328 in FIG. 3B. At step 328, processor 402 prompts for user input using the text string determined by either step 324 or step 326. In the next step 330, the processor 402 stores the value of the variable entered by the user with a manual input device 408, such as a mouse or keyboard.
[0038]
The step of the flowchart proceeds from step 330 to decision step 332. In step 332 of FIG. 3B, it is determined whether the current line of the script under consideration is the last line of the script. If not, at step 334 the processor 402 sets the next line of the script to the current line. The step proceeds from step 334 to step 308 where the processor 402 retrieves the current next line of the script. If it is determined in step 332 that the line under consideration is the last line of the script, the process proceeds to step 336.
[0039]
At step 336, processor 402 retrieves the value of the undefined variable stored at step 330 and generates a complete command line using the value as an additional argument. By doing so, the processor 402 places the value of the variable in the exact argument format required by the command line. The processor 402 preferably adds arguments in the order in which undefined variables appear in the script.
[0040]
Step 336 then proceeds to step 338 where the processor 402 provides the complete command line to the interpreter 104. Thereafter, the process proceeds from step 338 to final step 340.
[0041]
If it is determined in step 318 that the current variable is the final variable in the lookup table, the flowchart proceeds to step 332 in FIG. 3B. If no matching variable is found for a script line, it is assumed to be a line containing undefined variables.
[0042]
  An example of command line generation will be described using some script examples.
The first example script is UNIX(Registered trademark) Written in the Korn shell script language.
Script No.1
    line    command
     01 #! / Bin / ksh
     02 #ACCOUNT
     03 #CUSTOMER
     04 exec xterm-title "$ 2" -e account_viewer $ 1 &
[0043]
Lines 1 to 3 of script No. 1 are non-execution comment lines. Line 1 includes a Korn shell programming language text string identifier, or KSH, that is sought in step 304 of FIG. 3A. Line 2 is a comment line that identifies the undefined variable ACCOUNT listed in line 4. Similarly, line 3 identifies the undefined variable CUSTOMER, also listed in line 4. Lines 2 and 3 also have no text string following the variable name text string. Accordingly, in FIG. 3A, processor 402 uses step 326 rather than step 324 to instruct the user to enter the value of the variable. An example of a lookup table accessed by step 326 is presented below.
[0044]
In line 4, the text string “exec” is a command for executing the added argument, that is, the text string “xterm”. However, “xterm” is itself an X-Windows command for opening a window named according to the customer. The text string “-title” is a switch option that causes the window to be titled. The text string “$ 2” is an undefined variable representing the name used in the window title. The text string “-e” is a switch that causes the program (identified by the next argument) to run in the window. The text string “account_viewer” is the name of the program executed in the window. The text string “$ 1” is an undefined variable representing an account displayed by the program account_viewer. The text string “&” indicates background execution.
[0045]
  The command on line 4 is actually a nested command. UNIX(Registered trademark) The Korn shell parses the command line starting with the innermost nested command and works outward. UNIX like this(Registered trademark) The first undefined variable encountered by the Korn shell is the variable “$ 1” representing the account being displayed. Thus, the variable name ACCOUNT appears on line 2 before the variable name CUSTOMER on line 3. UNIX(Registered trademark) The second undefined variable encountered by the Korn shell is “$ 2” which identifies the customer name that appears in the window. Thus, the variable name CUSTOMER appears on line 3 as the second undefined variable.
[0046]
A skilled user of script “account_viewer.ksh”, ie script No. 1, would be able to manually create a command line that passes the required variables from line 4 of the script. However, unfamiliar users are confused and it is probably impossible to enter the command line correctly.
[0047]
The second script example is written in a tool command language (TCL).

[0048]
Line 1 of Script No. 2 contains the text strings “tcl” and “expect”. Either of these identifies the scripting language as TCL. Again, this text string is seeked by step 304 of FIG. 3A.
[0049]
Lines 2 to 4 of the script No. 2 list used undefined variables. Note that lines 3 and 4 contain a text string after the variable identification text string. Thus, the processor 402 proceeds from step 322 to step 324 and prompts user input using the subsequent text string. In contrast, line 2 directs processor 402 from step 322 to step 326 and prompts for user input using the text strings in the lookup table listed below.
[0050]
The command line for executing script No. 2 (named “sendmail”) is sendmail.tcl recipients filename subject-indicating-text. Here, the order of the arguments is very important. If an unfamiliar user determines an undefined variable, he must make a guess in the order of the additional arguments. There are six possible substitutions in the order of the three arguments. That is, 6 attempts are possible in the required command line. The command line generator according to the present invention removes from the user not only the order of adding variable values as arguments on the command line, but also the burden of having to identify or remember undefined variables in the script.
[0051]
  Example of a variable lookup table that stores all variables of the script language and text string used in either script No. 1 or script No. 2 when instructing the user to enter the value of the variable Is described below.
Variable Look-up Table (Look Up Table: LUT)
Variable name          Prompt string
ACCOUNT Please Enter The Customer Account Number
CUSTOMER Please Enter The Customer's Full Name
FILENAME Please Enter A File Name
RECIPIENTS Please Enter The File Name With The List Of Recipients
SUBJECT Please Enter A Subject Matter
The command line generator according to the present invention is suitable for use with any scripting language that can predefine a variable set. The above example is UNIX(Registered trademark) It is based on the Korn shell script language and the tool command language, and the present invention is particularly suitable for the WAMIL script language, but also adapts to other script languages as described above.
[0052]
The script is intended to be written by a command line generator according to the present invention. Such scripts first have a non-execution line that identifies the undefined variable being used. Each such non-execution line will probably contain only one variable name text string. However, existing scripts can be modified very easily by inserting such non-executable lines at the top of the script. In this way, it is possible to make existing scripts user-friendly with little effort.
[0053]
The advantage of the command line generator according to the present invention is not only the format in which the values of these variables should be presented as arguments added to the command line, but also the undefined variables used in the script. It is to free the user from the hard work that must not be done. In this way, the present invention makes it possible for unskilled users to use such scripts (in a practical way) with regard to scripts for proficient users. On the other hand, it is virtually impossible for users unaccustomed to use such scripts in the prior art. Furthermore, if the script writer considers use by an unfamiliar user, the script writer no longer needs to insert a multiple dedicated interface part into the script. Since the script writer can rely on the utility of the command line generator according to the present invention, it is only necessary to insert a comment line (preferably at the beginning of the script) that identifies undefined variables.
[0054]
As mentioned above, although the Example of this invention was described in detail, the same thing is realizable by various methods. Such variations should be considered as developing from the spirit and scope of the present invention. It will be apparent to those skilled in the art that other methods can be implemented without departing from the scope of the invention.
[Brief description of the drawings]
FIG. 1 is a command line execution diagram according to the prior art.
FIG. 2 is a diagram of command line generation in accordance with the present invention.
FIG. 3A is a flowchart illustrating steps in an embodiment of command line generation according to the present invention.
FIG. 3B is a flowchart illustrating steps in a specific embodiment of command line generation according to the present invention.
FIG. 4 is a block diagram of hardware for executing command line generation according to the present invention.

Claims (10)

A method for preparing a command line by a machine to initiate command line execution of a script, the script including at least one undefined variable for which a user enters its value as a command line argument during script execution. A method executed on the machine is executed prior to execution of the script, and the method executed on the machine comprises:
(A) providing the script;
(B) finding an instance in the script of the undefined variable for which the user enters its value as an argument on the command line;
(C) instructing the user to enter each of the at least one undefined variable; and (d) generating a complete command line, wherein the complete command line is transmitted to the machine. A method characterized by starting execution of a script, the complete command line comprising a step having an argument corresponding to the value obtained in step (c). The method of claim 1, wherein step (b) comprises:
(B1) treating the first line of the script as a text string; and (b2) searching the text string for all substrings corresponding to the undefined variable;
The step (c) instructs the user to input the value of at least one corresponding undefined variable found in the step (b2), respectively.
The method further includes:
(E) storing the one or more values received from the user in step (c); and (f) steps (b)-(c) and steps ( e) repeating the step. The method of claim 1, further comprising:
(e) A method comprising submitting the complete command line to a machine for execution of the script.   The method of claim 1, wherein the at least one undefined variable in the script represents a parameter of a wireless communication system. A method for preparing a command line by a machine to initiate command line execution of a script, the script including at least one undefined variable for which a user enters its value as a command line argument during script execution. A method executed on the machine is executed prior to execution of the script, and the method executed on the machine comprises:
(A) providing the script;
(B) treating the first line of the script as a text string;
(C) searching the text string for all subscripts corresponding to the undefined variable for which the user enters its value as an argument on the command line;
(D) directing the user to enter a value of the corresponding at least one undefined variable;
(E) storing the one or more values received from the user in step (d);
(F) repeating steps (b) through (e) for the remaining lines of the script; and
(G) generating a complete command line, starting execution of the script by sending the complete command line to the machine, wherein the complete command line corresponds to the value obtained in step (e); A method comprising the steps of having an argument. A computer readable storage medium containing a program for preparing a complete command line by a computer for starting a command line execution of a script, the script having a value as a command line argument when the script is executed by a user A program recorded on the computer-readable storage medium, including at least one undefined variable to be input, is executed prior to execution of the script, and the program recorded on the computer-readable storage medium is:
A first code segment providing the script;
A second code segment that finds an instance in the script of the undefined variable for which the user enters its value as an argument on the command line;
A third code segment for instructing the user to enter a value for each of the at least one undefined variable, and a fourth code segment for generating a complete command line, wherein the complete command line is transmitted to the computer A fourth code segment having a factor corresponding to the value obtained from the third code segment, the execution of the script by
A computer-readable storage medium comprising: The computer readable storage medium of claim 6.
The second code segment is:
A first code segment that treats the first line of the script as a text string, and a second code segment that searches the text string for all substrings corresponding to the undefined variable;
The third code segment directs the user to each input a value of a corresponding at least one undefined variable found in the second code segment, the computer-readable storage medium further comprising: ,
A fifth code segment for storing the one or more values received from the user via the third code segment, and for repeating the second code segment and the third code segment for the remaining lines of the script A computer-readable storage medium comprising a sixth code segment. The computer-readable storage medium of claim 6, further comprising:
A computer readable storage medium comprising a fifth code segment that passes the complete command line to the machine for execution of the script. A computer readable storage medium of claim 8, at least one undefined variables in the program embodying a computer readable storage medium, a computer readable storage medium characterized by corresponding to the parameter of a wireless communication system. A computer-readable storage medium containing a program for preparing a command line for starting command line execution of a script by a computer. The script inputs a value as an argument of the command line when the script is executed. A program recorded on the computer readable storage medium is executed prior to execution of the script, and the program recorded on the computer readable storage medium includes:
A first code segment that treats the first line of the script as a text string;
A second code segment that searches the text string for all substrings corresponding to the undefined variable for which the user enters its value as a command line argument;
A third code segment instructing the user to enter a value for each corresponding at least one undefined variable;
A fourth code segment for storing the one or more values received from the user via the third code segment;
A fifth code segment for repeating the first to fourth code segments for the remaining lines of the script, and a sixth code segment for generating a complete command line, the computer of the complete command line A computer readable storage medium comprising: a fourth code segment having a factor corresponding to a value stored from the fourth code segment, wherein execution of the script is initiated by outgoing to the complete command line.

Images