Overview

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

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.