Abstract

Two major Forth extensions provide high-level support for building rapid prototypes for systems. These extensions form distinct language vocabularies available in the Forth environment. One is a Finite State Machine Language, named FSML, and the other is an object oriented language, named 200L. Using these extension and the inherent expandability of the Forth language, a prototype can be rapidly created. The modeling method requires four steps. First, using 200L, the system is described as a set of objects. At least one of the objects must be a controlling object and so identified. Second, using FSML, the controlling object is described as a finite state machine. Third, the system's operation is expressed as a collection of one or more finite state machines. Each finite state machine type is defined with a unique machine type name. Any number of instances of a finite state machine type can be dynamically created at execution time. Fourth, communication is allowed between the finite state machines.

Description

This is a continuation of application Ser. No. 08/064,315 filed on May 20, 1993 now abandoned.

FIELD OF THE INVENTION

The present invention relates to programming of computer systems. More specifically, the present invention is a method of quickly implementing programming ideas into actual test code that can be used to test basic assumptions about the programming idea.

BACKGROUND OF THE INVENTION

To minimize risks and gain insight, many customers and vendors are cooperatively building prototypes and field trials, starting with simpler more restricted capabilities and gradually adding capabilities in phased steps. This can be done in stages, starting with software-only simulations, followed by hardware/software prototypes leading to the design refinements that can later be applied to a commercial system development with greatly reduced risk of unexpected and costly problems.

Software simulation of complex systems requires flexible software tools that can represent the logical systems design elements in an executable form, i.e, a Rapid Prototype. The tools are used to build a logical prototype of the system being studied. There are several kinds of simulation possible. For logical analysis of system models and protocols, a logical execution model works best. A statistical model and other mathematical models might be used for subsequent performance and reliability analysis.

The tools should support rapid creation of design elements that represent the level of logic being simulated. The prototype is recursively refined and expanded to implement the model in increasingly greater detail. This process quickly leads to deep insight about the model and problems as they are discovered.

To develop a rapid prototype, the tools should:

1) Minimize the conceptual distance between the logical model and the implementation;

2) Support logical representation at any level of detail without limitations imposed by resource of language constraints;

3) Retain flexibility during all phases of development; and

4) Provide an interactive user interface.

This arrangement can best be described as a spiral development strategy. One way to view the spiral is to picture a problem domain as a wheel with radial spokes defining sectors that represent parts of the problem. Traversing a spiral, beginning at the center of the wheel, one encounters a small piece of each part of the problem. With each successive traversal of the spiral, the radius grows so that the path becomes longer and the level of detail, represented by the areas of the circumscribed sectors, is increased. This process allows repeated evaluations over the full scope of the problem, each time with more detail as design choices are simulated with greater precision.

Prior to the present invention, a programmer wanting to test ideas or control systems had to expend a great deal of time creating a computer model on which the problem could be simulated. Before the programmer could begin testing any of the underlying assumptions, the model needed to be nearly complete. This required that many of the detailed decisions and associated coding be in place. The present invention provides a method to rapidly start testing high level design assumptions even prior to a detailed understanding of the low level responses.

Therefore it is the objective of the present invention to provide a method to rapidly reduce programming ideas and concepts into a working model whereby the programming ideas and concepts can be tested at a high level.

SUMMARY OF THE INVENTION

In order to accomplish the objective of the present invention there is a provided method for allowing a computer system to simulate a system. The invention is best described as four steps. First the system is described as a set of objects. At least one of the objects must be a controlling object and so identified. Second, the controlling object is described as a finite state machine. Third, express the system operation as a collection of one or more finite state machines. Create as many finite state machines as needed. These finite state machines can be statically defined with unique machine names. They can also be dynamically created at runtime, using the controlling finite state machine as the prototype. Fourth, allowing communication between the finite state machines.

DESCRIPTION OF THE DRAWINGS

A better understanding of the invention may be had from the consideration of the following detailed description taken in conjunction with the accompanying drawings, in which:

FIG. 1 is a high level block diagram showing the layers of the present invention.

FIG. 2 is a pictorial representation of memory usage by the C4TH primitives + and swap.

FIG. 3 is a pictorial representation of memory usage by a C4TH typical thread.

FIG. 4 is a pictorial representation of memory usage by a more complicated C4TH thread.

FIG. 5 is a pictorial representation of memory usage by a simple C4TH data word.

FIG. 6 is a pictorial representation of memory usage by the C4TH doer word.

FIG. 7 is a pictorial representation of memory usage by 200L for a static named object (SNO).

FIG. 8 is a pictorial representation of data structure built by the word method: in 200L.

FIG. 9 is a example of data structure built by the word method: in 200L.

FIG. 10 is a pictorial representation of memory usage by a 200L descriptor.

FIG. 11 ms a pictorial representation of memory usage by 200L as a result of the execution of short: +seed1.

FIG. 12 is a pictorial representation of memory usage by 200L as a result of the execution of m:.

FIG. 13 is a pictorial representation of memory usage by 200L.

FIG. 14 is a pictorial representation of memory usage by FSML for the keyword input.

FIG. 15 is a pictorial representation of memory usage by FSML for the keyword input.

FIG. 16 is a pictorial representation of memory usage by FSML for create-timer timer1.

FIG. 17 is a pictorial representation of memory usage by FSML showing a part of the thread for machine m1.

FIG. 18 is a pictorial representation of partial memory usage by FSML when creating states.

FIG. 19 is a pictorial representation of partial memory usage by FSML when creating state S0.

FIG. 20 ms a pictorial representation of memory usage by FSML once state SO is created.

FIG. 21 is a pictorial representation of memory usage by FSML for the word }.

FIG. 22 is a pictorial representation of memory usage by FSML for the word }.

FIG. 23 is a pictorial representation of memory usage by FSML showing the format of the "input" message.

FIG. 24 shows a rapid prototype for a basic call model

FIG. 25 shows an intelligent network environment.

DESCRIPTION OF THE PREFERRED EMBODIMENT

Referring to FIG. 1, at the lowest level, a Forth language nucleus is used. This particular implementation of Forth is in C to provide portability to a wide variety of host environments. Several properties of the Forth language have proven to be very important factors in minimizing the effort to build a rapid prototype.

1) Forth inherently provides an interactive user interface.

2) Forth is inherently an extendible language. New words added to the dictionary operate in an identical fashion as native Forth words. This makes it easy to create high-level, application-oriented language sets above the Forth nucleus to minimize the conceptual distance between the problem domain (the logical model) and the implementation language.

3) The Forth system provides efficient support for multi-task operations internal to an application.

4) The Forth system contains a wide variety of internal development tools that support testing and debugging operations.

5) Large complex problem domains can be implemented in great detail without restrictions due to resource exhaustion, even on relatively modest host platforms.

Two major Forth extensions provide high-level support for building rapid prototypes for real-time control systems such as telecommunication switching systems. These extensions form distinct language vocabularies available in the Forth environment. One is a Finite State Machine Language, named FSML, and the other is an object oriented language, named 200L.

Finite State Machine Language--FSML

FSML supports definition of an arbitrary set of communicating, finite state machines. Each Finite State Machine (FSM) runs as a separate task and can establish static or dynamic communication bindings with other FSMs. FSML syntax is simple. Referring to Table 1, each FSM is defined as a list of states. Under each state is a list of inputs that are valid for that state. Following each input is a next-state and action list (output) to be executed when the FSM receives the input while in that state. Inputs are programmer-defined tokens sent to an FSM via messages. Messages may contain any additional parameters needed by the application. FSML also supports the concept of sub-machines in which inputs are synchronously processed in the task-space of a parent FSM. This extension provides a natural expression of more complex finite state machines in which there may be states and sub-states. This has proven very practical in supporting solutions to real-world problems without incurring problems of un-bounded state expansion.

By way of an example, a Finite State Machine (FSM) is a specialized controlling object or structure that can be used to define the action of a system or subsystem. As stated above, an FSM is defined by it's states, input--next-state transition pairs, and action routines.

This FSM has 2 states, 1 and 2. When instantiated, it starts out in state 1. If this FSM receives an input X, it changes to state and performs action routine 1. Each state has an or-else clause to handle unknown inputs.

The following is an example of how a simple Voice Mail (VM) system could be modeled using an FSM. This example will be used as the steps involved in designing a model are explained below.

From this description, it is apparent that this machine has 4 states. The last line (start-state Choose-- VM-- Option) indicates that the starting state is the Choose-- VM-- Option state. Once in this state, the transition pairs determine both the next state and action taken for any given input. For example, if Button1 is pressed, the FSM changes to state Play-- Messages and the action routine causes the messages to be retrieved. The other states and transition pairs operate in a similar manor.

During the first few passes, the action routine may do nothing more than return a message that the desired action occurred without actually performing any action at all. This allows the designer to implement the FSM. Once the FSM is functioning, the actions routines can then be defined in greater detail. As stated above, the action routines may contain FSM (sub-machines) as well.

Tables 7 and 8 provide definitions for the FSML and FMTOS words along with a few screens for the more complicated words.

Object Oriented Language--200L

The other major extension to the forth operating system is 200L. 200L supports the object classes with the following language characteristics:

2. Polymorphism Method names may be common across classes, with specific functionality bound to each class.

3. Multiple-Inheritance Object classes all inherit the methods of the base class, CLASS0, and can comprise elements of other classes whose specific methods are automatically inherited.

4. Early And Late Binding Objects may be instantiated at compile time and be created as "static named objects". Both the class and the methods are bound at compile time (early binding). Objects may be instantiated at execution time (dynamic objects). When a method is to be applied ("sent to") an object, either the method index or the class descriptor or both may be supplied at execution time (late binding).

Object classes provide methods for creating objects that are named, static instances of a class or as dynamic, un-named instances of a class. 200L provides convenient access to un-named objects via named Object Handles which can be temporarily attached to dynamic objects, allowing them to be referenced by the Object Handle name as if they were named static objects. 200L supports object association via an alias method which allows an object's instance data to define a kind of pointer to another object, still inheriting all that object's methods as if the object itself were included.

In 200L, there are two kinds of objects; "classes" and "objects". A class is a specialized kind of object which may be "instantiated" to create specific objects whose form and operations are determined by the class definition. All class objects are members of the underlying 200L base class, called "CLASS0:". 200L classes can inherit the instance variables and methods of other classes by directly incorporating objects from those other classes within the class instance data definition. An instance of a class is created by using the MAKE method. The MAKE method will allocate the required amount of memory for all the instance data of the class, including the instance data that comprises objects of other classes. In other words, instances of inherited classes will be created at the same time an instance of the class is created.

200L syntax is consistent with the underlying Forth language suffix notation in which operation verbs apply to the contents of the parameter stack.

<parameters><object name><method name>

For example, "3 5 +" will leave "8" on the stack. Operation verbs for 200L objects are called methods. A "method" is the object-oriented terminology for a function or procedure.

Object oriented design encourages a change in mindset from thinking of data and procedures that operate upon the data as separate entities to the viewpoint that a program consists only of Objects which have various behaviors, determined by the methods supported by-each object. The objects are then viewed as building blocks to be combined in many ways to build programs that accomplish the desired tasks.

Accordingly, an object named X in 200L could be printed by the statement:

X PRINT,

where PRINT is a method defined for the object class of object X.

200L class data definitions allow a wide variety of primitive data types, including signed and unsigned variables of various sizes, structures, unions, and arrays. These elements may be combined as needed for the applications, creating arrays of structures of variables, or structures including arrays of elements, for example. Instance data may include objects of other classes and inherit all the methods applicable to those objects. Of course, these may also be arranged in structures and arrays, as required. 200L class methods and instance data may be declared as private or public. Object instance data is normally private, and cannot be referenced outside the object, and must be accessed only by the methods defined for its class.

The MAKE method is used only for static named objects. For example, to make an instance of a class named classx: and name the instance X the following coding would be used:

classx: MAKE X

Although not required, by convention all classes in 200L have names ending with a colon. Another convention is to use upper case (or mostly upper case) letters in method names. There is no particular convention for object names.

There is no UNMAKE for static named objects. They are created at compile time and remain persistent as long as the load exists.

The DMAKE method is used to create dynamic instances of a class. Dynamic objects do not have names. The DMAKE method returns an object address on the parameter stack. It is up to the programmer to manage the addresses of dynamic objects. 200L provides the ability to define named object handles which can be assigned the class descriptor and the object address of any dynamic object. Typically, object handles are associated permanently with a particular class descriptor and then assigned different object addresses dynamically as the system operates. The object handles allow dynamic objects to be referenced by the object handle name in the same way a static named object can be referenced by its name. The only difference is that the object handle must be attached to the object address at execution time as it is used to reference different instances of objects of its class.

There is a DUNMAKE method that can be used to destroy dynamic objects and return their memory resources to the system.

The following small example shows how to create an object handle and attach it to a dynamic instance of classx:

After all the discussion about instantiating classes to create objects, the user will still be unprepared to use this information if he or she doesn't know how to define a class in the first place.

A class consists of a definition of the "instance variables" and the class-specific definition of the methods that operate upon those variables. The class "instance variables" are defined as a structure of the data elements that act as a template for the data to be created for each instance of the class. The class instance data structure defines an organization of data elements of several kinds:

The ?method: word is used to pre-define the method names. This is a conditional definition, only if the name has not already been defined as a method before. Method names are associated with an arbitrary system index which is used to link the definition of the method for a specific class in the class descriptor table compiled uniquely for each class definition. Method names are all placed into the OOL vocabulary to avoid conflicts with user defined words in other vocabularies. The ?method: definitions do not have to be within the class: and ;class words. There is an alternative method: word that will redefine the word with a new index, but this would be an unusual thing to do.

Note that ?method: definitions were only used in this class definition for the CLONE and $ASN methods, because the other method names are all predefined within 200L itself. Method names are global, but must be bound to each specific class. The specific definition within a class is provided by the m: definitions. Note that other generic methods, such as DUMP, LIST-METHODS, SIZE, etc. may also be applied to instances of this class, but have not been redefined specifically for this class. These will inherit the CLASS0: definitions provided within 200L.

The user may provide a new definition of any of the CLASS0: methods within a new class, and the new definition will be used on objects of this class. The new definition can reference the CLASS0: definition of the method as part of the new definition, if desired.

For example, if the user wanted to redefine the DUMP method for the example class above so that it printed out an additional string before dumping the object with the CLASS0: dump, the new definition could be coded:

The private: word is used to declare the following definitions to be hidden from access from anywhere outside the class definition. The instance data definitions are typically made private. The names of instance data elements, such as +CsID in the example, are also a form of method. These names return the offset of the data element from the top of the object's address space. The public: word makes following definitions accessible outside the object. The private: and public: mode words can be interspersed in the class definition as desired to control the information hiding for any methods.

By convention, instance data element names begin with "+" to emphasize the offset they return must be added to the object address. This shows up within the m: definitions where the object address operator "oa" must be used for referencing the instance data. The oa operator satisfies the compile time requirement of providing the class descriptor needed when compiling a reference to a data element, and at execution time it provides the object's base address to which the element's offset is automatically added for element references.

Tables 2 to 5 list the added forth words for 200L. Table 6 provides a definition for the 200L words along with a few screens for the more complicated words.

Description of Inner-Workings of 200L and FSML

Both FSML and 200L may be thought of as special purpose compilers, extending the syntactic constructs which can be handled in the FORTH environment: the FSML compiler supporting those constructs associated with a Finite State Machine Language and the 200L compiler supporting those constructs associated with Object Oriented Programming.

In order to understand the implementation of these two special purpose compilers, it is first necessary to have a basic understanding of the compilation and interpretation process supported by the underlying C4TH system. The C4TH implementation provides for three basic types of words: primitives, threads and created words.

A primitive word is one whose behavior is provided by a single C function which is called any time the primitive is executed. There is a one to one relation between the primitive and the C function. The implementation of two primitives, + and swap, is illustrated in FIG. 2. The + primitive takes the top two items on the parameters stack, adds them together, and leaves the result on the parameter stack. The swap primitive takes the top two items on the parameter stack and interchanges their relative positions--the top item becomes the second item and the previously second item is now on top; i.e., it swaps one for the other.

The implementation consists of two portions, a header and the word, which are linked together. The main content of the header is a string of ASCII characters giving the symbolic name of the word. When the user types in the name of a word to be executed or compiled, the headers are searched to find one matching the name typed in by the user, and once a match is found, a pointer in the header indicates where the word itself is stored.

The word in turn indicates what action should be taken when the word is executed. In the case of all words, the CFA points to a C function which is to be executed when the word is executed. For a primitive, there is no other action which will occur beyond the execution of the associated function. In a primitive the DOES> field is always 0.

FIG. 3 illustrates the implementation of a typical thread. In this case, it represents the execution behavior of the word "u." whose behavior is commonly defined by the colon definition

: u. <# #s #>type space ;

Like all words in C4TH, it has an associated header and it begins with three fields:

1 'HEADER--points to the associated header

2 DOES>--if this word was created by a defining word using the CREATE--DOES>construct, this field points to the DOES>portion of the defining word. Otherwise this field is 0.

3 'CODE--points to an associated C function which will be immediately executed to start the execution of this word. In the case of a primitive, this C function will be the only thing executed when this word is executed. In the case of a thread, this field points to a C function named xcolon.

These three fields are followed by the parameter field of the thread. This consists of a series of pointers to words which are to be consecutively executed when the thread is executed. Data parameters serving as inputs to these words may be intermixed with the pointers. This is not illustrated in FIG. 3 but can be seen in FIG. 4. FIG. 4 shows a more complicated arrangement of threads, such as would be produced by the compilation of the following two statements:

: u. <# #s #>type space ;

: test 7+u. ;

The effect of the word test is to add seven to the value on the top of the parameter stack and print the results. When the word test is executed, the interpreter pointer (IP) points to the beginning of the parameter field as shown in FIG. 4.

The code for the inner interpreter is shown immediately below the interpreter pointer. As it executes, it performs a doubly indirect function call to the C function xlit, advancing the interpreter pointer to the next position in the thread, leaving it pointing to the literal value 7. The xlit function places the value pointed to by the interpreter pointer, 7, onto the parameter stack and advances the interpreter pointer, leaving it pointing to the reference to +. xlit then returns control to the inner interpreter.

The inner interpreter then performs a doubly indirect function call to the C function xplus, advancing the interpreter pointer to the next position in the thread, pointing to the reference to "u.". xplus adds the top two values on the parameter stack and leaves the result on the parameter stack. It then returns control to the inner interpreter.

The inner interpreter then performs a doubly indirect function call to the C function xcolon, advancing the interpreter pointer to the next position in the thread, pointing to the reference to ";". xcolon pushes the current value of IP onto the return stack, and then sets IP so it points to the beginning of the thread in the word "u.". It then returns control to the inner interpreter. In effect, xcolon has performed a transfer of control from the thread test to the thread "u." in a manner analogous to a subroutine call. At the completion of execution of the thread "u" control can be returned to the thread test using the value saved on the return stack.

The inner interpreter then consecutively executes the code for each of the words specified in the thread for "u.". At the conclusion of the thread for u. the inner interpreter will execute the code associated with the reference to ";"--the C function xsemicolon This function pops the top of the return stack, placing the return address back into IP. This is analogous to a return from a subroutine call, and at the conclusion of this operation, xsemicolon returns control to the inner interpreter which will resume interpretation of the thread for test.

At this point the end of the thread test has been reached and xsemicolon is called once again, returning control to whatever routine had originally invoked test.

Created words come in two flavors:

1. Simple data words, and

2. more complicated doer words.

A simple data word provides storage for one or more items of data. When it is executed, it simply returns the address where the data can be found. An example is shown in FIG. 5. The 'CODE field of a simple data word always points to a C routine called xvar and the DOES> field is 0. When executed, xvar returns the address of the parameter field for the word which called it.

Simple data words are commonly brought into being using the word create which will create a word whose 'CODE field points to xvar. The user will then store data into the word using storage allocation words such as "," or allot. The example shown in FIG. 5, which contains the values of the first eight prime numbers, could be created using the following C4TH code:

create xlat-- tbl 2, 3, 5, 7, 11, 13, 17, 19,

Such a word could be used together with another word to return the value of any of the first eight primes, given a number as an input. An example of such a word would be

: Nth-prime (u1--u2) CELL * xlat-- tbl +@;

In practice, one could view xlat-- tbl as a simple array, and Nth-prime as a word which accesses the Nth entry of that array.

The more complex doer words also provide storage for data, but in addition they provide an associated access routine which determines what happens when the doer word is executed. In every doer word the 'CODE field points to the C function xxdoes and the 'DOES> field points to a thread which describes the access behavior for the word.

An example is shown in FIG. 6. The arrangement illustrated in FIG. 6 would be created by the following code:

array (-- ) create does>(u1 -- u2 ) swap CELL * +@;

array xlat-- tbl2 2, 3, 5, 7, 11, 13, 17, 19,

: test-- it 4 xlat-- tbl u. ;

This is similar to the previous example, in which we created a word called xlat13 tbl. However, this time the word xlat13 tbl2 is a doer word. Any time it is referenced, it will use the top value on the parameter stack as an index into its contents and return the corresponding value. The word test13 it is a simple test word illustrating the behavior of xlat13 tbl2.

When test13 it is executed, it will place the value "4" onto the parameter stack and then execute xlat13 tbl2. When xlat-- tbl2 is executed, the C function xxdoes takes control and does the following:

1. It pushes the current value of IP onto the return stack.

2. It loads IP with the address contained in the 'DOES> field of xlat-- tbl2. In effect it has transferred control to the access routine specified by the does> portion of the word array.

3. It pushes the parameter field address of xlat-- tbl2 onto the parameter stack. This will provide an input to the access routine, letting it know where the data can be found.

4. It then returns control to the inner interpreter, which will then proceed to execute the thread given by the access routine in array.

The access routine uses the index value "4" (second item on parameter stack) together with the address of the data (first item on the stack) to compute the address of the fourth item of data and fetch its contents. At the end of the access routine, the primitive xsemicolon is executed, returning control to the thread in test-- it which then prints the result--11. Note that the index value "4" actually accesses the fifth element of the array in xlat-- tbl2; i.e., it uses 0-based indexing.

200L and FSML operate by creating words and data structures which appear to be ordinary words to the inner interpreter; i.e., it can interpret their behavior just like any other words.

FIG. 7 illustrates the format of an important data structure created by 200L called a static named object (SNO). Such an object could be created by the 200L syntax

<classname>MAKE test

A static named object has the following properties:

1. It has a header in the dictionary and an associated symbolic name; i.e., it has a name by which it can be referenced.

2. It is actually implemented as two related words--wordA and wordB. wordA is executed any time the word is being referenced by its symbolic name (note that the CFA field of the header points to wordA).

3. When an SNO is referenced by its symbolic name, wordA is executed and generates a reference to the second word, wordB. It also leaves the address of the descriptor for the SNO on top of the parameter stack. In generates the reference to wordB in one of two different fashions, depending on whether the C4TH system is in interpret or compile mode (identified by the contents of the user variable state):

a) If state is 0, indicating that C4TH is in interpret mode, wordA will leave the address of the parameter field of wordB as the second item on the parameter stack. It will leave the address of the descriptor on top of the parameter stack.

b) If state is non-zero, indicating that C4TH is in compile mode, wordA will compile the address of the code field of wordB into the dictionary. It will also leave the address of the descriptor on top of the parameter stack. When the thread which is being compiled executes, it will in turn execute wordB which will at that time leave the address of its parameter field on top of the parameter stack.

4. When a reference to wordB is executed, it will leave the address of its parameter field on the parameter stack, indicating where the data can be found.

Any time a reference is made to a SNO using its symbolic name, the address of its descriptor is left on top of the parameter stack. This address is used by the following method name to determine what class the SNO belongs to. Knowing the class to which the object belongs and the name of the method which is to be applied to that object, it is then possible to generate a reference to the thread for the appropriate method to be used to operate on the object.

200L

The implementation of 200L is presented by describing, step by step, how the 200L system handles a typical example of 200L code. The example is as follows:

Note that each line is preceded by a line number. These line numbers would not normally be present in 200L code, but are placed in the example to facilitate referencing individual lines in the description which follows.

Line 01: the word method: is a keyword defined in 200L. It takes the following word provided by the user, in this case the word set-- seed, and defines it as the name of a method. It does this by defining the word set-- seed as a doer word method: allocates a unique index number which it assigns to set-- seed. This index number is subsequently used to cross-reference the symbolic name set-- seed with the actual method code defined in the class. The data structure built by method: is illustrated in FIG. 8.

Index values are assigned starting with the value 4. Each new index value is four greater than the preceding value; i.e., the two least significant bits are zero. These bit positions will be modified depending on whether the method is public or private method: also provides the access routine used by set-- seed any time set-- seed is referenced. This access routine expects that, at the time of reference, the top value on the parameter stack will point to a class descriptor. The access routine takes the following actions:

1. It performs a sanity check to verify that the top item on the parameter stack was a pointer to a class descriptor.

2. It then searches through the methods-list of that class descriptor, looking for a methods-- node whose index field matches the index value assigned to this method. If it does not find such a methods-- node, then this method is not valid for that class and an error message will be output.

3. Assuming that a methods-- node can be found, then the access routine will determine the address of the code for the method and will either execute that code immediately or compile it into the dictionary, as appropriate.

Lines 02 and 03: like Line 01, these lines define two additional method names: raw-- random and rand. The corresponding data structures are illustrated in FIG. 9.

Line 04: the word class: is a keyword defined in 200L. It starts the definition of a new class by doing the following:

It creates and initializes a descriptor for the class random.

It loads the variable curr-class with the address of the descriptor for random.

It leaves a value of 0 on the top of the parameter stack. As each element making up the structure of the class random is defined, this value will be incremented by the number of bytes of space required by that element. At any given time this value indicates the offset from the beginning of the object to the position occupied by the next element to be defined. After all elements have been defined, this value will indicate the size of an object of this class.

The initial data structure for the descriptor is illustrated in FIG. 10. The contents of this descriptor will be modified as the class is further defined.

The descriptor consists of four elements:

1. A descriptor list which will eventually comprise a linked list of descriptor nodes, each of which will describe a portion of the structure of an object belonging to this class. At the time the descriptor is created by the word class:, the descriptor list is empty, indicated by the 'DN-- NODE field being null (0).

2. A methods list which will eventually consist of a list of method-- nodes, each of which identifies one or more methods which are defined for this class. At the time the descriptor is created by the word class:, the method list consists of a single item--a method-- node which points to the descriptor for CLASS0. This method node indicates that all of the methods defined for CLASS0 are also defined for the new class random.

3. A size field which indicates the natural size in bytes occupied by an object which belongs to this class. At the time the descriptor is created by the word class:, the size is not known and this field is initialized with a value of 0.

4. A subclass list which links together all the subclasses which may be defined within this class. At the time the descriptor is created by the word class:, the subclasses are not yet defined and the subclass list is empty, indicated by the 'subclass field being null (0).

Line 05: private: indicates that those methods which are subsequently defined should be treated as local to this class and not accessible to words which are defined outside the scope of this class definition. The word private: is very simple--it clears a flag in the variable public-flag. Those keywords which define methods always examine this flag at the time they define a method and make it public or private accordingly.

Line 06: the word short: is a keyword defined in 200L. It takes the following word provided by the user, in this case the word +seed1, and defines it as the name of a method. It also indicates that the first element of any object belonging to the class random should be treated as a short (2-bytes long), signed integer. As the word short: executes, it performs the following actions:

It defines a new method, much as method: does, giving it the name +seed1.

It creates a descriptor node indicating that the first element within an object of the class random is a short, signed integer.

It attaches this descriptor node to the end of the descriptor list.

It creates a method node, indicating that the method +seed1 is a valid method for the class random.

It attaches this method node to the beginning of the methods list of the descriptor for the class random.

It creates a word sharing the symbolic name +seed1 and having the execution time behavior necessary to access this element in any object belonging to class random.

It increments the offset value found on the top of the parameter stack by two, indicating that the size of an object belonging to class random is known to be at least two bytes long and that the next element to be defined will be at an offset of two from the beginning of the object.

The results of executing short: +seed1 are illustrated in FIG. 11. Those portions of the figure which are shaded indicate data structures created and initialized by the word short:. The format of the method-- name (lines 1-4) is virtually the same as that created by method: and its 'DOES> field points to an access routine that is essentially identical to that generated by method:. Like any method name, it has a unique index value.

A method-- node created by short: has three fields:

1. A link field used to link method-- nodes together into a linked list--the methods-list.

2. An index field which stores the same index value that is associated with the method name; i.e., there is a one-to-one association between the contents of this field and the method name. When this field is initialized, the least significant bit is set to "1" if the public-flag indicates that this method should be treated as public for this class. Otherwise this bit is cleared to zero.

3. A 'method field which stores the address of the word which specifies the behavior of this method for this class.

Given the symbolic name of a method, it is easy to determine the associated index value. It is then possible to search the methods-- list of any given class descriptor to find a method-- node having a corresponding index value. If no such method-- node can be found, then that method is not defined for that class. Assuming it is found, it is then possible to go from the method-- node to the address of the code which is to be executed when that method is applied to an object belonging to the class.

A descriptor-- node has three fields:

1. A link field used to link descriptor-- nodes together into a linked list--the descriptor-list.

2. A 'descr field which points to a descriptor providing information about the element.

3. A copies field which indicates whether the element is actually an array of items described by the 'descr field, or whether it is in fact a single item of the type specified by the 'descr field. A value of -1 indicates that this is a single item, not an array.

short: will always create a descriptor node whose 'descr field points to a descriptor for the class SHORT. This descriptor is provided as part of 200L. This descriptor indicates that the size of an object (or element) of type SHORT is 2 bytes. Its descriptor-- list is empty. This is characteristic of a data type which does not contain any substructure. Its methods-- list contains methods-- nodes for a number of methods which are defined by OOL as being applicable to an object (element) or type SHORT. This includes methods such as PRINT, DUMP, A DDR, SIZE, !!, MAKE, etc.

The method created by short: is relatively simple and is structured like a doer word. Its 'HEADER field points back to the header for the symbolic name +seed1. Its 'DOES> field points to an access routine which adds the offset of the element to the top value on the parameter stack which contains the base address of the object. The effect of this is to generate the address of the element +SEED1. Like all create-does> words, the 'CODE field points to the C function xxdoes(). The parameter field contains a single value--the offset of the element. Since +seed1 is at the first element in the object, the offset value is 0.

Line 07: the word short: is encountered once again. It takes the following word, +seed2, and handles it almost identically to +seed1. A different, unique index value is assigned and the offset value is now pb 2 instead of 0. The value on top of the parameter stack is incremented by 2 (the size of a short element), leaving a result of 4.

Line 08: public: indicates that those methods which are subsequently defined should be treated as publicly known; i.e., not restricted to use only by methods defined within this class. public: is the opposite of private: and like private: it is easily implemented--it sets a flag in the variable public-flag.

Line 09: m: starts the definition of the method set-- seed by performing the following actions:

1. It uses the C4TH dictionary search routines to verify that there is a method-name defined for set-- seed. If it cannot find such a method-name, it returns an error message.

2. Assuming the method-name is found, it obtains the index number assigned to that method-name.

3. It constructs a method-node, using that index value, and links the method-node into the methods-list.

4. It constructs the first part of a word definition--the 'HEADER, 'DOES>, and 'CODE fields.

5. It initializes 'HEADER to point to the header for the method-name; 'DOES> to 0; and 'CODE points to the C function xcolon(). This word will be a thread.

6. It compiles the CFA for set-oa as the first entry in the thread.

7. It then puts C4TH into compile mode, allowing C4TH to compile the rest of the method.

The word set-oa handles a simply utility function required at the beginning of the execution of any method--it saves the current value of the constant oa onto the return stack and places the top value from the parameter stack into the constant oa. By convention, this value will be the base address of the object that the method is acting on.

When the word m: completes execution, that data structures are as shown in FIG. 12. Note that descriptor-nodes are inserted into the descriptor list at the tail of the list. This ensures that a traversal of the descriptor list from the beginning to the end corresponds to a traversal of the elements in the object from base address to the end of the object.

Methods-nodes are inserted into the methods-list at the front of the list. This allows a method to be defined multiple times within a class but only the most recent, public version of the method will be recognized.

Line 10: ;m completes the definition of a method. It compiles the word mexit into the dictionary and then invokes the word ";". The word mexit performs the inverse function of set-oa--it pops the top value from the return stack and places it into the constant oa, restoring the value that oa had prior to the start of execution of the method. The result of compiling lines 9 and 10 is shown in FIG. 13.

Lines 11 to 16: define two more methods--raw random and rand. The compilation of these lines is no different than that of lines 9 and 10.

Line 17: ;class completes the definition of the class random. It does so by performing the following actions:

1. It takes the top value from the parameter stack and places it into the size field of the class descriptor. In the case of the class random, this value will be 4.

2. It then invokes the conceal routines to mark the private methods as invalid. The conceal routines traverse the methods-list, searching for those method-nodes whose index field has the least significant bit clear, indicating that they are private, not public. It then sets bit 1 of the index field for each of these method-nodes. When bit 1 is set, the search routines which search the methods-list for a given index value will fail to find a match on these methods-nodes; i.e., they will no longer be detected as valid for this class.

This method of hiding methods-nodes which are private was chosen because it is easily reversible for debugging or for exceptional cases where two classes need to share information which is otherwise private.

Line 18: random MAKE my-- random will create an instance of the class random and give it the symbolic name my-- random. The following actions take place as these words are executed:

1. The word random is the name of a class descriptor which is itself an object belonging to CLASS0:. Its behavior is the same as any other object name: It places the address of its contents (the descriptor for the class random) onto the parameter stack. It then places the address of the descriptor of the class to which it belongs, CLASS0:, on top of the parameter stack.

2. The word MAKE is the name of a method. Like any other method-name, it expects to find the address of a class descriptor on top of the parameter stack. It then searches the methods-list for this class, CLASS0:, to see if there is a method-node whose index value matches that of the method MAKE. Such a method-node exists and points to the code which will construct an object belonging to the class random. This code will now be executed.

3. The MAKE method expects to find the address of a descriptor on top of the parameter stack. This was provided by the word random. The code for MAKE examines the size field of the descriptor and creates a static, named object having the specified amount of storage. The word which follows MAKE will be used as the symbolic name for the object--my-- random. The contents of my-- random will be undefined.

Line 19: 478 my-- random set-- seed will initialize the contents of my-- random. The following actions take place as this code is executed:

1. 478 leaves the literal value 478 on top of the parameter stack.

2. my-- random is the name of an object. It places the address of its data contents onto the parameter stack. It then places the address of its class descriptor on top of the parameter stack.

3. the word set-- seed is a method. Like any other method-name, it expects to find the address of a class descriptor on top of the parameter stack. It then searches the methods-list for this class, random, to see if there is a method-node whose index value matches that of the method set-- seed. Such a method-node exists and points to the thread which was defined for set-- seed. This code will now be executed.

4. As the code for set seed executes, it first finds the address of the object, my-- random, on top of the parameter stack. The word set-oa saves the value of oa and places the object address into oa so that future references to oa will return the object address. set-- seed then performs the initialization, placing the value 478 into the +seed1 element of my-- random, and 0 into the +seed2 element. At the end of set-- seed, the word mexit restores the original contents of oa.

Line 20: 6 my-- random rand operates in a manner perfectly analogous to that of line 19.

FSML

The implementation of FSML is presented by describing, step by step, how the FSML system handles a typical example of FSML code. The example is as follows:

Line 01: input is a keyword defined in FSML. It takes the following word and makes it the symbolic name for referencing an input to a machine. It does the following:

1 It generates a unique token value that will be used to uniquely identify this input when received by a machine.

2 It creates a constant having the symbolic name (in this case in0) and initialized to the value of the unique token.

3 It links the new word into a linked list of all inputs.

4 It compiles the value 0CCE8H as the next entry in the dictionary.

The results of this are shown in FIG. 14. The value CCE8H is compiled to provide a convenient means of checking whether a particular entry in the dictionary is an FSML input--if the third entry in its parameter value is 0CCE8H, it is assumed to be an FSML input.

Line 02: defines another logical input name--in1. The actions taken are virtually the same as those indicated for Line 01. The results are shown in FIG. 15.

Line 03: defines another logical input name--tm1. The actions taken are virtually the same as those indicated for Lines 01 and 02.

Line 04: tm1 20 create-timer timer1 has the effect of defining a type of timer whose symbolic name is timer1. It does this in the following steps:

1 tm1 is the name of an input, and like all inputs acts like a constant. When it is executed it returns its value on the parameter stack. In this case the value 3.

2 20 is a literal value which leaves the value 20 on top of the parameter stack.

3 create-timer does most of the work. It creates a timer structure whose symbolic name is timer1. Execution of a reference to timer1 will return the address of the timer structure.

The results of this code are shown in FIG. 16.

Line 05: user t1 is just ordinary C4TH code, reserving a user variable which will subsequently be used to store the timer token returned by starting the timer.

Line 06: machine ml begins the definition of a type of machine which will be named m1. The work is done by the word machine which does the following:

1 It creates a simple data word whose symbolic name is m1. It then proceeds to initialize the contents of this word, making it something of a hybrid between an ordinary data word and a thread.

2 It initializes the variable curr-mach to point to the parameter field of the word m1.

3 It compiles the literal value 0FEESH as the first entry in this word. This value is used for sanity checking--verifying whether a word is a valid machine type.

4 It begins compiling a thread; starting with a section of code which will initialize the starting state of the machine when it is executed. Because the starting state is not known at this time, the variable 'st is set up pointing to the fragment of code which will need to be fixed up later to identify the proper starting state. The results of this are illustrated in FIG. 17.

5 It then switches C4TH into compiling mode, allowing the normal C4TH compilation process to complete the compilation of the thread.

Line 07: ."activating instance of m1" cr specifies a fragment of code which is to be executed any time a machine of type m1 is created and starts running. Normally this would be problem specific initialization code. In this case it is a simple message indicating that the machine has been created and started executing.

Lines 08 to 10: states terminates the definition of the initialization code and begins a block of code which will identify the symbolic names of all of the states for the machine m1. It performs the following actions:

1 It compiles a reference to (run-mach) at the end of the initialization code. (run-mach) is the actual routine which handles input processing for a machine; i.e., when initialization processing is complete, (run-mach) gets control and starts processing inputs as they become available.

2 It executes the word ; allowing it to finish the thread.

3 It then loops through the next series of words, making each of them the symbolic name for a state. The looping process terminates when it encounters the keyword end-states.

The result of this process is shown in FIG. 18. The data structures for each of the state names have the following properties:

The state names are simple data words, so their execution time behavior is to return the address of their data contents.

The first field is initialized to 0. While the behavior of the state is being defined, this field will serve as the head of a linked list of all the threads of code which specify the actions for each of the inputs which are defined for this state.

The second field is initialized to -1. This is a flag indicating that the state name has been defined but has not yet been used in a statement such as state s0. When the state behavior is specified, this field will point to the State Input Table associated with that definition.

The third field is a link field. All state names for a particular machine are linked together in a linked list. st-lnk is a variable which points to the first entry in this linked list.

The fourth field is the constant value 09ADDH which is used for sanity checking to determine whether a particular word corresponds to a valid state name.

The fifth field is a pointer to the data structure generated by the word machine. In this fashion, given a state name, it is possible to determine what machine it is associated with.

Line 11: end-states has no behavior of its own. It simply serves as a terminal indicator for states, indicating the end of the list of states.

Line 12: state s0 begins the definition of the behavior exhibited by the machine while it is in state s0. All of the work is done by the word state which takes the following actions:

1 It checks s0 to verify that it is a valid state name, defined by states . . . end-states.

2 It verifies the fact that this is the first occurrence of state s0; i.e., the behavior of s0 has not been previously defined.

3 It begins building the State Input Table entries required to define this states behavior.

a) It places an entry in the SIT that points back to the body of the state name.

b) It places a pointer to the routine process-input into the SIT, indicating that this routine should be used to evaluate the contents of the subsequent entries in the SIT.

4 It stores in the second field of the state name definition of s0 a reference to the relative position in the SIT of the link to process-input. This information will be needed at a later time to patch up address references which cannot be initially resolved.

The results of this processing are illustrated in FIG. 19.

Line 13: in0 s0 {. "received in0 while in s0"} specifies the behavior of state s0 When input in0 is received. Most of the work is done by the word {. The following actions occur:

1 The word in0 is executed and leaves its value on the stack, a "1".

2 The word s0 is executed and leaves the address of its associated data on the stack.

3 The word { is executed and performs the following actions:

a) It verifies that the input value left on the stack is valid and produces an error indication if it is not.

b) Assuming the input value is valid, it is entered into the SIT.

c) The current value of here is entered into the SIT. This provides a pointer to the location in the dictionary where the thread which defines the action associated with the input will be located.

d) The preceding three steps will be repeated until there are no more input values remaining on the parameter stack. In the case of this example there is only a single input value, but the syntax of FSML allows for multiple values.

e) It checks the address left by s0 to verify that it is indeed the address of a valid state name.

f) It begins to construct the thread which will be executed any time a machine of type ml receives an input value of in1 while in state s0. It links this thread into a linked list of threads associated with the state name s0. This is done via the first element in the data for the state name. Eventually this link field in the thread will be replaced with the identity of the next state s0.

g) It then concludes by putting the C4TH system into compile mode, allowing the regular C4TH compilation process to finish compiling the thread. At this point in time, the appropriate data structures are as illustrated in FIG. 20.

4 The C4TH compiler processes the code fragment ."received in0 while in s0" and compiles it into the thread.

5 The C4TH compiler encounters the word } which is immediate and executes it.

6 The word } terminates the compilation of the thread. Depending on a user option, it may compile a reference to (stk-chk) at the end of the thread. This word performs a runtime check for spurious data left on the stack. } then calls ; to terminate the definition.

The results of all this processing are shown in FIG. 21.

Lines 14 and 15: in1 s1 {. "received in1 while in s0" timer1 start-timer t1! } is processed in virtually the same fashion as the preceding line. The result of this processing is illustrated in FIG. 22.

Line 16: or-else s0 {. "unexpected input while in s0" } is processed in the same manner as the preceding lines. Note that as far as FSML is concerned, or-else is just another input whose value happens to be -1. FSML does enforce a syntax rule that if an or-else input occurs, it must be the last input within the state definition.

Lines 17 to 22: these lines are processed in the same manner as lines 12 to 16.

Line 23: start-state s0 concludes the definition of the machine m1. start-state has a lot of work to do as follows:

1 It verifies that the word which follows, s0, is the name of a state which has been defined for machine m1. If it is not it generates an error message.

2 Assuming it is a valid state, it patches the reference in the initialization code to refer to the portion of the State Input Table which is associated with this state.

3 It then copies the State Input Table into the dictionary.

4 It then traverses the list of all state names associated with the machine m1, verifying that all states are reachable and resolving all pointers to the State Input Table, replacing them with the actual addresses occupied by the SIT in the dictionary. It is at this point that the next state field of all of the action threads is updated to indicate the next state value.

5 It then reinitializes various compilation state variables to allow the definition of any additional machines.

Line 24: m-schedule m1 alias mtm creates an instance of the machine m1 and creates an alias name for the instance, making it convenient to refer to the machine instance by the symbolic name mtm. The following actions take place:

1 m-schedule creates a task using the facilities of FMTOS. It initializes this task such that when the task begins to execute, it will start interpreting the thread of initialization code associated with the machine m1.

2 m-schedule also creates a pipe for handling input messages and initializes the new task's user variable my-pipe to point to that pipe.

3 m-schedule then initializes the recovery procedure for the new task to point to mrcvy-rout, the default recovery routine for an instance of a finite state machine.

4 m-schedule completes its activity by placing the new task in the scheduling queue and returning a token pointing to the task control block.

5 alias takes the token provided by m-schedule and creates a constant having that token as its value and the symbolic name mtm.

As soon as the machine mtm gets control from the task scheduler it will begin executing its initialization code. It will print out the message activating instance of ml followed by a carriage return. As it reaches the end of the initialization code, it will begin executing the routine (run-mach) which will essentially loop forever, waiting for inputs and processing them as they arrive. (run-mach) will immediately attempt to remove an input message from the input pipe. In all likelihood, none will be available and the task will block, waiting for an input.

Line 25: select mtm makes the machine specified by mtm the "current machine". This is a convenience provided for debugging, making it easy to interactively send inputs to the selected machine.

Line 26: in1 >>> sends the input in1 to the currently selected machine. Most of the work is done by >>>. The following activity occurs:

1 in1 leaves its value, 2, on top of the stack.

2 >>> takes the top value from the parameter stack and makes an input message from this input value

3 >>> then sends the input message to the selected machine, mtm. The format of the input message is illustrated in FIG. 23. Sending the message will unblock mtm, placing it back into the scheduling queue.

The message has five fields:

FLINK and BLINK and linked list pointers used to link the message into the input pipe of the receiving machine.

'TCB gives the task identity of the task which sent the input. This is provided primarily for debugging.

IN contains the value of the actual input.

'PROCESS contains the value that the user variable process had at the time the input message was sent.

As soon as the machine mtm gets control from the task scheduler, (run-mach) resumes execution and does the following:

1 It saves the current state in a variable mstate,

2 It removes the value of 'process from the input message and places it into the user variable 'process.

3 It removes the input value from the input message and places it into the user variable in-save.

4 It checks to see whether the input message originated from a timer operation. If so, the buffer is not attached to the input pipe and should be released using an input operation. Otherwise, the empty input message is returned to the pipe.

5 It then transfers control to input processing routine specified for the current state, commonly process-input.

6 process-input will search the State Input Table associated with the current state, looking for an input value which matches the received input. Once this is found, it will transfer control to the thread indicated by the SIT and update the current state to indicated next state. This thread will perform the actions specified for the received input. When the thread is completed, it will return control to (run-mach) which will once again wait upon another input.

Line 27: 73 >>> sends the input value 73 to the currently selected machine. The processing is virtually the same as that for line 26, however, 73 will not be a recognized input value, causing activation of an or-else action.

HOW TO DESIGN A MODEL

With an understanding of the FMTOS, 200L, and FSML extensions to C4th, the user is ready to create a model which simulates a target real-world system being investigated.

First Level--Identify and Classify Main System Objects

a. Describe the system as a collection of objects which relate as directly as possible to the target system components. Identify the objects as "controlling objects" and "controlled objects". "Controlling" objects can receive input stimuli from and possibly send outputs to the environment (which can be a user at a terminal, data link to another system, another controlling object, etc.) There must be at least one controlling object.

b. Inputs and outputs must be defined as event messages which, at a minimum, must correspond to event tokens (an event token is unique value specifying a specific event). A message may also contain other information elements whose forms may be later specified in detail by 200L (non-controlling) object class definitions.

c. Controlling objects should be specified as Finite State Machines, using FSML. When a Finite State Machine receives an input event, it generally executes a state transition and manipulates other non-controlling objects which represent the elements of the system that are being controlled.

d. Controlled objects do not need to be implemented until the controlling processes of the controlling objects are operational and well understood. This implies the controlling can accept all input events and make all state transitions properly.

To define new controlled objects, the user will usually need to create new 200L object classes corresponding to the objects that represent the system being modeled. New classes comprise a definition of instance data for the class and a set of methods that (usually) operate upon that data. The instance data is defined in terms of primitive data objects pre-defined in 200L, and as instances of other pre-defined 200L object classes.

Define new methods as required:

a. Methods defined generally in the Forth language primitives within the context of 200L class definition.

b. Methods which invoke the inherited methods of the objects that comprise the new class's instance data.

c. Methods which invoke other methods of the new class that were defined earlier in the class definition.

Second Level--Refinement of Finite State Machine (FSM) Controlling Objects

Designing an FSM requires the following steps:

a. Determine all the states.

b. Identify all inputs, and which inputs are valid in each state.

c. Define which state the machine should transition to for each valid input.

d. State what action should be performed for each input-transition pair. The "action routine" during initial design should be nothing more than a printed message to the user about the action to be taken.

Third Level--Communicating FSMs

Each FSM definition defines a "machine type". When the system executes, One or more instances of each machine type must be created as an synchronously executing task. FSML provides several communication mechanism alternatives for both "connection-oriented" and "connectionless" communication linkages. Establish the most appropriate type according to the system being modeled and implement these mechanisms.

Fourth Level--Expand Detail

The complete system operation consists of communicating FSM processes. In the VoiceMailbox example, inter-FSM communication takes place between coexisting VoiceMailbox FSMs sending and receiving messages with each other. With each iteration of development of the model, the "controlled object" classes are implemented and the "action routines" are expanded to execute the methods of these objects. In the end, the model replaces the text display of desired action routing function by the actual execution of those actions upon the controlled objects of the system.

Basic Call Model Example

By way of an example, the present invention was used to model the Intelligent Network (IN) as characterized by a Basis Call Model comprising a set of call state, called Points-In-Call (PICS), to define Originating and Terminating Basic Call models in conjunction with a model of the switch connectivity state defined in terms of a set of Connection View (CV) objects. With the Basic Call Model (BCM) as simulated by the present invention, a generic switching systems is simulated in terms of finite state machine states and CV objects. Message communication between this simulated switching system and Service Logic Execution Environments (SLEEs) is modeled according to various protocol alternatives.

The IN concept is intended to make the public telecommunication network more flexible and responsive to the changing needs of the network users. This is to be achieved by modifying existing central office switching systems, and designing new switches, so that their call processing logic can be controlled or influenced by other network elements (external computers programmed by telephone operating company personnel). The motivation for this is the long lead time required by switch vendors to provide new services and features in the switches' embedded generic software packages and the amount of-time needed to deploy the new services and features to all switches within a network.

Prior to IN, it has been impractical to support large-scale local customization of central office switch-based features, to accommodate unique requirements of specific customers, and to introduce interfaces to other external computerized services. The IN concept makes these arrangements more feasible. Referring to FIG. 25, The IN strategy is to define a small set of standardized points of control, called Detection Points (DPs), within new and existing central office switch software. At these points the switch will suspend normal processing logic and send messages to Service Logic Programs (SLPs) within other computers, called Service Logic Execution Environments (SLEEs), external to the switch. The SLP then responds to the switch query with a response message that indicates which of several actions the switch should take as the next step in processing the call. Through a sequence of such interactions, an SLP can control a central office switch to effect service scenarios not provided directly by the switch software. The IN concept brings with it a variety of concerns including: stability of existing network elements, development costs, complexity management, inter-vendor compatibility, OAM&P issues, future evolution paths, and others.

In creating the Basic Call Model Rapid Prototype (BCMRP), two major FSM classes were defined; one for the Bellcore Originating Basic Call Model (FSM.O-BCM), and one for the Terminating Basic Call Model (FSM.T-BCM). See FIG. 24. The BCM PICs are represented as states in FSML. A typical, simple two-party telephone call requires an instance of an O-BCM and an instance of a T-BCM. More complex telephone calls may involve many more separate O-BCM and T-BCM instances which are interconnected and able to communicate by messages.

Although FSML syntax allows any arrangement of Forth code to be provided to specify the actions to be performed when a particular input occurs in a particular state, the BCMRP is implemented by combining all actions into special action words so that for every state-input pair, the action to be taken is defined by a single action word. This improves the clarity of the FSML code, emphasizing the table-like structure for states, inputs, next-states, and actions. Table 1 shows an excerpt of actual FSML code for the O.Actv (Originating BCM ACTIVE PIC) submachine.

In the BCMRP, the main control logic is implemented as a set of communicating FSMs, implemented in FSML. The action words invoked by the FSMs perform their work by applying the Method operations to the objects which define the fabric of the system. The BCMRP represents all CV elements (Call Segments, Legs, Call Segment Associations, etc.), all messages and parameters as 200L objects. The BCMRP represents elements of an actual prototype's database as a set of 200L objects. For example, a line accessed via jack C38 on the prototype can be referenced by object name C38 in the BCMRP. Since C38 is an instance of a telephone line object class, it can respond to methods such as ORIGINATING, DIALING, ANSWER, HANGUP, MAKE-BUSY, and so forth, in addition to primitive 200L methods such as DUMP and PRINT.

To initiate a new telephone call from line C38, one could input:

C38 ORIGINATING

The BCMRP would create a new Originating BCM instance and prompt the user for the valid next inputs for the AUTHORIZING-- ORIG-- ATTEMPT PIC. If the Originated detection point is not activated for that particular line in the switch's database, the BCMRP would automatically Continue and enter the COLLECTING-- INFO PIC at which time the user could input:

C38 DIALING '854-9123

and the BCMRP would prompt the user for the valid next inputs for the AUTHORIZING-- ORIG-- ATTEMPT PIC and the BCMRP would advance the O-BCM to the INFORMATION COLLECTED PIC.

Every switch event is analyzed for Detection Point criteria, and if the criteria are satisfied, a SLEE message is created. The message is displayed in user-readable form on the terminal, and the user is then prompted with a list of all valid SLEE responses. At this time, the user can select which SLEE response is to be received, and a SLEE message is constructed. All valid SLEE response messages are derived from the current FSM state (PIC) whose specifications are encoded in FSML for the specific call model implemented. Once a particular message is selected, the user is prompted for all parameter values and optional parameters. Depending upon the user's choices, the BCMRP will simulate various switch actions in terms of the abstract switching machine defined by the BCM PICs and conductivity states represented by the CV objects. These are displayed after each response, and the user is again prompted for all valid next events.

Ordinarily, the BCMRP attempts to simulate most switch actions automatically, but the user can override almost any switch action with whatever actions are valid within the BCM and message protocol specifications.

The BCMP interactive mode is usually used to create scripts which can then be saved as text files and run through the BCMRP in batch model This makes it easy to build a large library of call scenarios by deriving new call variations from previous call scripts.

An optional output mode causes the BCMRP to create a Feature Test Plan (FTP) output file, where the human actions, such as call origination, are listed along with the resulting switch-to-SLEE messages and SLEE-to-switch messages in a formal ASN.1 syntax form that is post-processed into specific GTD-5 EAX TCAP messages used in conjunction with switch testing tools. In this way, call scenarios that have been verified on the BCMRP are then automatically compared with the actual switch operation.

Although the preferred embodiment of the invention has been illustrated, and that form described, it is readily apparent to those skilled in the art that various modifications may be made therein without departing from the spirit of the invention or from the scope of the appended claims. ##SPC1##

Claims (6)

What is claimed is:

1. A method for a user to design a computer system to simulate an external system, said method comprising the steps of:

using the Forth collection of programming environment building blocks to create a finite state machine language and an object oriented language;

using said Forth collection of programming building blocks, said finite state machine language and said object oriented language to define said external system as a plurality of objects, said plurality of objects consisting of at least one controlling object;

said objects comprising a plurality of data where said plurality of data describes said object; and

a plurality of operations that can be performed by said computer system on said plurality of data;

defining said at least one controlling object as a finite state machine;

defining said system as a plurality of finite state machines;

defining communication protocols between said plurality of finite state machines;

determining a closest match between said object and a previously defined object;

selecting said closest match and creating a new object based on said closest match;

defining said plurality of data for said object; and

defining said plurality of operations for said object.

2. A method as claimed in claim 1 wherein each of said steps of defining said controlling object and said system as finite state machines comprises the steps of:

defining a plurality of states that said finite state machine can assume;

defining a next state transition pair, for each of said plurality of states said next state transition pair describes a next state for said finite state machine;

defining an action routine for each of said next state transition pair, said action routine describes what action said computer should take when said finite state machine transitions to said next state.

3. A method as claimed in claim 2 wherein each of said steps of defining said controlling object and said system as finite state machines further comprises the steps of:

for each of said plurality of states, defining only valid inputs;

defining said next state for each of said valid inputs; and

defining said action routine for each of said valid inputs.

4. A method for designing a computer system to simulate an external system, said computer system being operated by a user through a user interface, said method comprising the steps of:

using the Forth collection of programming environment building blocks to create a finite state machine language and an object oriented language;

using said Forth collection of programming building blocks, said finite state machine language and said object oriented language to define said external system as a plurality of objects, said plurality of objects consisting of a controlling object;

said objects comprising a plurality of data where said plurality of data describes said object; and

a plurality of operations that can be performed by said computer system on said plurality of data;

defining said controlling object as a finite state machine;

defining communication protocol between said finite state machine and said user through said user interface, said user inputs stimuli to said finite state machine and said user observes responses of said finite state machine to said input stimuli;

determining a closest match between said object and a previously defined object;

selecting said closest match and creating a new object based on said closest match;

defining said plurality of data for said object; and

defining said plurality of operations for said object.

5. A method as claimed in claim 4 wherein each of said steps of defining said controlling object and said system as finite state machines comprises the steps of:

defining a plurality of states that said finite state machine can assume;

defining a next state transition pair, for each of said plurality of states said next state transition pair describes a next state for said finite state machine;

defining an action routine for each of said next state transition pair, said action routine describes said responses said computer will output to said user through said user interface when said finite state machine transitions to said next state.

6. A method as claimed in claim 5 wherein each of said steps of defining said controlling object and said system as finite state machines further comprises the steps of:

Computer system and computer implemented process for representing software system descriptions and for generating executable computer programs and computer system configurations from software system descriptions

Computer system and computer implemented process for representing software system descriptions and for generating executable computer programs and computer system configurations from software system descriptions