With ObjectScripting, you can
automate tedious manual tasks, integrate tools and utilities into the IDE,
and even add new custom features. Many of the operations of Paradigm C++ Professional
are implemented through scripting. This is one reason for the speed, power
and flexibility of Paradigm C++ Professional. Extensive online Help including instruction
and examples will get you started writing scripts to simplify your work.
ObjectScripting lets you customize
the Paradigm C++ Professional IDE using built-in classes and a scripting language called
cScript, a language very much like C++. cScript supports classes, late binding,
object-specific method overriding, and dynamic variable typing.
Through an object called IDEApplication,
which is instantiated when Paradigm C++ Professional first starts up, you can access
the different parts of the IDE, including the Editor, the debugger, the
keyboard, and the Project Manager. You can customize them to suit you, as
well as add your own new features.
cScript is a late-bound, object-oriented
language, which is roughly analogous to being an interpreted language. This
gives cScript programs more flexibility than early-bound programs, such
as those written in C++.
There are some key differences
between C++ and cScript. In C++, everything about a program is known at
compile time. The types of variables; the return type and parameters to
functions; the classes that will be used as well as all their properties
and behaviors are all known when the program is compiled.
In cScript, while the syntax
looks very similar to C++, you cannot declare a variable's type at compile
time. cScript variables are generic and can hold any type of data needed
at run time. In fact, the same variable can hold different types of data
as the program executes. Just as in C++, you create classes with properties
and methods and create objects that are instances of those classes. But
in cScript, you are free to override the methods for a given object (not
the class, just the object itself) at run time with a new implementation
of the method or a method "borrowed" from another object.
This means that an object of
one class can use the methods of an object of another class without having
to know anything about the second object at compile time. Existing objects
can have their functionality extended without the need for the source code
to the object's class, and without recompiling.
|Automate tedious tasks|
|Integrate tools and utilities
|Script Language similar to C++|
|Object-specific method overriding|
|Dynamic variable typing|