A web service is software on a web server that listens for requests and waits to perform a specific job. The MapleNet web service, in particular, waits to run Maple commands.

A desktop application that has a network connection can communicate with the MapleNet web service to perform computations. The client computer that runs the desktop application does not require Maple, a Maple license, or specific software to communicate with the web service.

The server-side infrastructure for Maple web services is provided by the MapleNet API. You can build client applications to use the MapleNet web service by using tools such as the Microsoft C# toolkit, Apache™ Axis plug-in for Eclipse, IBM® WebSphere®, and the NetBeans IDE.

Web services are defined by using a file containing the Web Services Description Language (WSDL). Before creating a client application, download the definition of the MapleService by using the WSDL file located at the following URL.

http://yourserver.com:port/maplenet/services/MapleService?wsdl

This URL points to a link on your server where MapleNet is installed. yourserver.com is the name or IP address of your MapleNet server and port is the HTTP port on which your server listens for requests (for example, 80 or 8080).

This URL can be used in your web services toolkit so that you can create the code to connect to the MapleService web service.

The following language-independent APIs are the most commonly used methods in the web service.

The evaluate method accepts a string that is a valid Maple expression and returns a string corresponding to the results generated by Maple after evaluating that expression.

The callMaple method accepts an array of strings of valid Maple expressions and returns an equivalent number of strings corresponding to the results generated by Maple after each expression is evaluated.

When a call to the web service is complete, the Maple kernel is released. In other words, the state (for example, variable assignments) is not preserved.

Results are returned from the web service call as text. The text can either be a 1-D Maple output expression or a Base64-encoded plot. Plot results take the following form.

In this example, _Base64GIF is a literal text string, which indicates that the result is an encoded plot. Following this string are two integers indicating the width and height of the output plot. Finally, data is the binary plot data, which is a Base64-encoded .gif image. A Base64 decoder must be used to translate the data into binary data that can either be rendered by your client application or written out to form the bytes of a .gif file.

For more information and examples, refer to the MapleNet Publisher's Guide.

Embedding a Maple application is easy: save your Maple document on a MapleNet server, open a web browser, and point to the saved .mw file. Your worksheet is not only visible, but also interactive if you included buttons, plots, or other embedded components in the .mw file.

Maplet applications are also easy to publish over the web.

Maple can also be embedded in larger web applications and used as the underlying computation engine for your application. For example, by using MapleNet functionality, you can use Maple as the graphics engine for scientific or business plots; you can also create an equation editor to read formula input or display formatted equations.

You can also use two other technologies to include Maple as part of your web applications: Java applets and JavaServer Pages (JSP).

Java applets, in conjunction with the MapleNet Java API, extend the browser capabilities beyond those provided by HTML alone. For example, the Maple equation editor is an applet that you can use to capture input using natural math notation. Another applet allows you to embed 3-D plots with controls for rotation, zooming, and changing properties such as constrained access and color shading. By using the Java API, you can create custom applets, for example, an applet that plots points in-place where you click, and uses Maple to compute a smooth curve that interpolates the points. To run applets, you require a Java-enabled browser.

JSP provides an alternate technology. Unlike applets, JSP pages are resolved on the server; the client computer only processes HTML code. Therefore, no special requirements are needed for the browser or computer running the browser to display the JSP results.

JSP is an extension to HTML. An HTML file can be extended by adding <maple> tags. When the web server displays one of these pages, it replaces the <maple> tags with the result of the specified computation. The result is an embedded image, text, or any other element that you want to include.

MapleNet comes with complete documentation and detailed examples. For more information on the Java applet and JSP APIs, refer to the MapleNet Publisher's Guide.

To run your application, two paths must be set up in your local environment.

In Windows, depending on the source programming language, calls to initialize the OpenMaple interface will locate these paths automatically so that the Maple commands will work without additional configuration steps.

Note: If your application does not initialize, set your Windows %PATH% environment variable to include the Maple bin.win or bin.X86_64_WINDOWS directory. To find out which path to use, run the kernelopts(bindir) command in Maple.

In UNIX, Linux, Solaris, and Macintosh, the MAPLE, and LD_LIBRARY_PATH or DYLD_LIBRARY_PATH environment variables must be set before starting your application. To set these environment variables, add the following lines to the start-up script of your calling application, where $MAPLE is your Maple installation directory.

These commands run the maple launch script to configure your environment without starting Maple. The period (.) prefix in a Bourne shell causes the commands to be sourced, thus, applying the settings to future sessions. Starting the application would be done via the above script rather than calling the executable directly.

Each OpenMaple application contains the following components:

The examples in this section show how to run a Maple computation using the OpenMaple API. Each example evaluates an expression and then exits. The examples in this section are intended to help you get started using the API. For detailed examples and descriptions, refer to the OpenMaple help page.

Additional examples are available in the samples/OpenMaple directory of your Maple installation.

The method used to build this program depends on which compiler you are using. The following command is specific to the GCC compiler on a 64-bit version of Linux; it is useful as a reference for other platforms.

In this example, $MAPLE is your Maple installation directory. Note that the C header files can be found in the $MAPLE/extern/include directory and the library files can be found in the $MAPLE/bin.$SYS directory. In this case,$SYS is X86_64_LINUX; check the library path you need to specify by running the kernelopts(bindir) command in Maple. The remaining -l options specify which libraries need to be linked. In Windows, you only need to link to the maplec.lib library. Other platforms may require several libraries to be linked, including libmaplec.so, libmaple.so, and libhf.so. If you do not specify a library as required, the compiler returns a message indicating that undefined references to functions exist, or a dependent library cannot be found.

When this example is built, a file called test.exe is created. Note: The file might be called a.out or another name, depending on your compiler. Before this executable file can be run, you must specify the path of the Maple dynamic libraries. For more information, see Runtime Environment Prerequisites.

After setting up your environment, run the binary file as you would run any other executable file. For example, create a shortcut icon and double-click it, or enter the file name at a command prompt.

The following output is displayed.

To build this example, you can open a Microsoft .NET Framework SDK Command Prompt. Browse to the directory that contains the test.cs file and enter the following command.

$MAPLE is the directory in which Maple is installed. The maple.cs file contains the MapleEngine class definition. and defines an interface to the maplec.dll file.

When this example is built, a file called test.exe is created. This file can usually be run without additional environment settings. For more information, see Runtime Environment Prerequisites.

Run the binary file as you would run any other executable file. For example, create a shortcut icon and double-click it, or enter the file name at a command prompt.

The following output is displayed.

This example and others are available in the samples/OpenMaple/Java/simple subdirectory of your Maple installation.

To build this program, enter the following at a command prompt, where  $JDKBINDIR is the directory in which your Java development tools are installed, and $MAPLE is the directory in which Maple is installed.

Note: The same command can be used to build the example in UNIX and Macintosh; however, use a colon (:) to separate the directories in the classpath instead of a semicolon.

When this example is built, a test.class file is created in the current directory. Before this file can be run, the path of the Java OpenMaple native library must be specified for your Java Virtual Machine. For more information, see Runtime Environment Prerequisites. In Windows, Java OpenMaple applications also require the %PATH% environment variable to be set.

You can use the Java Virtual Machine to run the generated class file by entering the following command. Note that the third entry in the classpath is a period (.) indicating the current directory.

Note: The same command can be used to build the example in UNIX and Macintosh; however, use a colon (:) to separate the directories in the classpath instead of a semicolon.

The following output is displayed.

Other examples are available in the samples/OpenMaple/msvb directory of your Maple installation.

To build this example, create a new project, and add both the test.bas and $MAPLE/extern/include/maple.bas files to your project.  $MAPLE is the directory in which Maple is installed.  Create a form called "MainForm" and add a text box named "OutputText" to the form.

Build and run this example by pressing F5. When this example is built, a form that shows a text box filled with the value 1/2*x^2 is displayed.

To build this example, create a new project, and add both the test.bas and $MAPLE/extern/include/maple.vb files to your project.  $MAPLE is the directory in which Maple is installed.  Create a form called "MainForm" and add a text box named "tbOutput" to the form.

Build and run the example by pressing F5. When this example is built, a form that shows a text box filled with the value 1/2*x^2 is displayed.

Maple allocates memory from the operating system in large portions. On most platforms, this process is performed by the C malloc function; 64KB of memory is allocated during a Maple session. This memory is not returned to the operating system (that is, by free) until the Maple session ends.

When Maple no longer requires a block of memory, that memory block is added to an internal list of free storage. Maple has several storage lists for different sizes of memory blocks so that it can quickly find blocks of the required size. For example, Maple uses three-word blocks, so it maintains a list of blocks of that size that are free. Maple allocates additional memory from the operating system only when it cannot respond to a request using its storage lists.

The more memory Maple is allocated by the operating system, the less it is allocated in the future because it reuses memory. For most applications, 4MB of memory must be available for allocation.

A batch file is a Maple script that can run in the Maple command-line interface, run statements, and exit. The results can be displayed or directed to a file.

One method of using the command-line interface to solve a problem is to create an .mpl script, which includes the input data. If this script is called solve.mpl, you could run the script as follows.

In this example, the output is redirected to a file named solve.output. You can configure an application to read this output file to capture the result.

Note: .mpl is the standard file extension for a Maple language file, which is a text file that can contain Maple statements. For more information, refer to the file help page.

You can use the -q option to hide extra output that interferes with parsing results automatically. For more options on the Maple command-line interface, refer to the maple help page.

To avoid using the file system, input to the command-line interface can be directed to a pipeline. The following example shows how to perform this task at a command prompt.

You can use the -c option to specify start-up commands to be run by the Maple command-line interface. Although the -c option can be followed by any valid Maple statement, the syntax must be carefully quoted to avoid being interpreted by the shell of the calling system. For example, the following syntax can be entered at a Windows command prompt.

The equivalent command in a UNIX shell requires different quoting.

Statements that do not use characters that are special to the system interpreter can be left unquoted, as with the case of -c N:=1; above. This statement does not use spaces, pipe characters, redirect symbols, quotes, or other characters that have meaning to the interpreter.

Most external functions that are compiled in a .dll file use standard hardware types such as integers, floating-point numbers, strings, pointers (to strings, integers, and floating-point numbers), matrices, and vectors. Maple can translate the hardware representation of these external functions so that the external functions are recognized in Maple. This method is efficient and easy to use because it does not require the use of a compiler. This method of directly calling the external code allows you to use an external library without modifying the Maple library.

To understand the Maple external calling facility, consider the following C code, which adds two numbers and returns the result.

Three basic steps are required to call a function in a .dll library.

Maple uses its own notation to provide a generic well-defined interface for calling compiled code in any language. The format of each type descriptor parameter is as follows.

The return value description is also defined by using a data descriptor, with the name RETURN as the argumentIdentifier. If the function returns no value, no RETURN parameter is specified. Also, if no parameters are passed, no argument identifiers are required.

External libraries generally handle scalar data formats that are supported by your platform. All array, string, and structured formats are created from these. The data descriptors used to represent scalar formats usually contain a type name and size. The size represents the number of bytes needed to represent the given hardware type. Table 14.1 lists the basic type translations for standard C, Fortran, and Java compilers.

Note: The C type long is typically 4 bytes on 32-bit systems and 4 or 8 bytes on 64-bit systems. Use the sizeof operator or consult your compiler documentation to verify sizeof(long).

In addition to the basic types listed in Table 14.1, Maple also recognizes certain compound types that can be derived from the basic types, such as arrays and pointers. These compound types are listed in Table 14.2. For a complete list and a detailed specification, refer to the define_external,types help page.

Alternatively, you may want to call call a .dll file that directly manipulates Maple data structures, rather than converting them automatically to standard data types. By doing so, you can either write custom applications that are integrated with Maple or provide custom conversions for data passed to prebuilt .dll files. Maple provides an API for directly managing Maple data structures and operations performed on them.

This API, or external function interface, is a subset of the API provided by the OpenMaple interface. Unlike the OpenMaple interface, you do not need to define stream callbacks because Maple is the primary interface. Also, the kernel-vector handle returned from a call to the StartMaple function in the OpenMaple API is, instead, passed as an argument to the external function defined in your .dll file.

Currently, the API is defined for C/C++ and Fortran, and certain portions of the API can be used for external functions written in Java. Other languages such as Visual C# and Visual Basic can interface through a small C++ layer.

The API function prototypes for manipulating Maple data structures are located in the $MAPLE/extern/include directory where $MAPLE is the directory in which Maple is installed. The header file maplec.h must be included when writing custom C wrappers. One of the header files, maplefortran.hf or maplefortran64bit.hf, must be included when writing custom Fortran wrappers. Other header files, mplshlib.h, and mpltable.h contain macros, types, and data structures that are needed for direct manipulation of Maple data structures.

In your C code, Maple uses the following lines as an entry point to call the external function directly with no argument conversion.

Two parameters are in the external function declaration. The first is a handle that will be required to call any Maple API function. The second is a Maple expression sequence of all the arguments passed when the external function is called. The API function MapleNumArgs can be used to determine the number of elements in the expression sequence. This variable can be treated as an array of DAGs starting at index 1 (not 0). Therefore, args[1] is the first parameter passed to the external function.

When using the define_external function to declare an interface to an external function that directly manipulates Maple structures, you do not need to provide a description of the arguments and their types. Instead, add the keyword option, MAPLE.

Again, consider the simple example that adds two numbers passed by Maple. This time, with explicit data type conversions using the API, and defining the external function prototype, as described above, the C function appears as follows.

This program first checks if the Maple function call passes exactly two arguments. It then converts the two arguments to hardware integers and adds them. The result is converted to a Maple integer and returned.

This program can be compiled into a .dll file using a C compiler of your choice. Ensure that you link with the Maple API .dll file. The .dll file can be placed in the Maple binary directory, as given by kernelopts(bindir), or a subdirectory within the directory specified by the PATH environment variable. If you are using .dll files outside of the Maple binary directory, you may need to specify the full path to the .dll file in the LIB argument to the define_external function. UNIX developers may also need to set their load-library path.

To complete the example, the myAdd function can be linked in Maple and used as any other Maple procedure.

The equivalent Fortran wrapper is as follows.

Once compiled into a .dll file, the same syntax can be used in Maple to access the function. The only difference is the additional keyword 'FORTRAN' in the define_external call.

For more examples, refer to the define_external,CustomWrapper help page.

Each programming language uses a specific convention for parameter passing. For example, C uses the pass-by-value convention; passing parameters by reference must be performed explicitly by passing an address. Fortran uses the pass-by-reference convention. Pascal uses either, depending on how the parameter was declared.

The Maple external calling mechanism supports C, Fortran, and Java calling conventions. There is an external API for writing custom wrappers for C and Fortran, but not for Java. The default convention used is C. To use Fortran calling conventions, specify the name FORTRAN as a parameter to the define_external function.

To use Java calling conventions, specify the name JAVA as a parameter to the define_external command. Also, specify the CLASSPATH= option to point to the classes used.

Some other compiler implementations, such as Pascal and C++, can work with C external calling by using the correct definitions and order of passed parameters.

When you specify the keyword WRAPPER in the call to the define_external function, Maple generates code for data translations. Maple compiles this code into a .dll file and dynamically links to the new library. Subsequently invoking the procedure that is returned by the define_external function calls the newly generated conversion command before calling the external function in the library you provided.

The C code generated by Maple wraps the Maple data structures by translating them to hardware equivalent types. Therefore, the code file is called the wrapper, and the library generated by this code is called the wrapper library.

Generating wrappers can provide an easy way to start writing custom code that references the Maple external function interface. The term wrapper also refers to the code you write to communicate with existing .dll files, as it does for the code Maple generates for the same reason. Your code is sometimes called a custom wrapper.

Consider the original add function that was introduced at the beginning of this chapter. In the following example, the WRAPPER option is used to generate a wrapper using the define_external function. As shown, you can also use the NO_COMPILE option to prevent the generated wrapper from compiling. The name of the generated file is returned instead.

The file mwrap_add.c resembles the following.

The generated wrapper is a good starting point for writing your own code. Some extra variables and declarations may be used because the wrapper generation is generic. For example, the use of args rather than fn_args avoids the need for a cast with args[1], but it is also a static global variable which is useful when working with callbacks that need access to the argument sequence outside the main entry point.

External functions follow normal Maple evaluation rules in that the arguments are evaluated during a function call. It therefore may be necessary to enclose assigned names in right single quotes (unevaluation quotes) when passing arguments by reference. For example, consider the following function that multiplies a number by two in-place.

In Maple, the definition of this function could appear as follows.

When running this function, the argument 'i' is converted from the Maple internal representation of an integer to a 4-byte hardware integer. A pointer to the hardware integer is then passed to the external function, 'double_it'. Although 'i' is declared as a pointer to an integer, you can call 'double_it' with non-pointer input.

In this case, a pointer to the hardware integer 3 is sent to 'double_it'. The modified value is not accessible from Maple. To access the modified value, the parameter must be assigned to a name. The name must be enclosed in unevaluation quotes to prevent evaluation.

For numeric data, the string "NULL" can be passed as a parameter to represent the address 0 (the C NULL). For strings, because "NULL" is a valid string, the integer 0 represents the address 0.

In the concat example, the C code might look like the following. Note that this function does not clean the memory as it should.

An external API is provided if you want to expand existing wrappers or write custom wrappers. Because this API is the same as that of OpenMaple, most of the internal documentation is referenced in the OpenMaple help pages. In particular, refer to the OpenMaple,C,API and OpenMaple,VB,API help pages and related pages.

Additional examples can be found in the examples,ExternalCalling page. Sample code is provided in the samples/ExternalCall directory of your Maple installation. In particular, all of the external calling sample code provided in the individual help pages in OpenMaple,C,API can be found in the samples/ExternalCall/HelpExamples directory. This code is precompiled in the HelpExamples.dll file provided with Maple so that you can run the examples in your Maple session.

The Maple kernel cannot control the quality or reliability of external functions. If an external function performs an illegal operation, such as accessing memory outside of its address space, that operation may result in a segmentation fault or system error. The external function may stop responding and cause Maple to stop responding as well.

If an external function accesses memory outside of its address space but within the Maple address space, the external function will likely not stop responding, but certain parts of Maple may not function correctly, resulting in unexpected behavior or a crash later in the Maple session. Similarly, an external function that directly manipulates Maple data structures can produce unexpected results by misusing the data structure manipulation facilities.

Therefore, use external calling at your own risk. Whether an external function is one that you have written, or supplied by a third party to which you have declared an interface (that is, by using the define_external function), Maple must rely on the integrity of the external function when it is called.

A socket server can be a public web service such as a stock quote service. The following example shows how to create a Maple procedure that acts as a service that listens for a socket connection and sends a message when a connection is found.

The server action is defined in the following procedure.

The following commands cause the Maple session in which they are called to start the servicing requests. This call is not returned. To run the code, enter the procedure definition above and the Serve command below in a Maple worksheet. (Remove the comment character (#) before running the code.)

To write a simple client, the socket must first be opened. To do so, specify the name of the host and the port number of the host to which you want to connect.

To get information from the server, the socket must be read.

When you are finished, close the socket.

Because the Maple programming language differs from the target languages supported by the CodeGeneration package, the generated output may not be completely equivalent to the input code. The CodeGeneration/Details help page provides more information on the translation process and hints on how to take full advantage of the facilities. In addition, some help pages contain notes that are relevant to specific languages. For more information, refer to the help pages for the corresponding target language, for example, CodeGeneration/General/CDetails.

The CodeGeneration commands recognize a subset of the Maple types, which are listed in the CodeGeneration/Details help page. The Maple types are translated to appropriate types in the target language. Compatibility of types is checked before operations are translated, and type coercions are performed if necessary. The CodeGeneration commands attempt to determine the type of any untyped variables. You can control type analysis and deduction by using the coercetypes, declare, deducetypes, and defaulttype options. For more information, refer to the CodeGenerationOptions help page.

The CodeGeneration commands can translate a subset of the Maple commands, which are listed on the CodeGeneration/Details help page. Some commands are translated only to certain target languages. For more information about a specific language, refer to its detailed help page, for example, CodeGeneration/General/CDetails.

The return type of a procedure is determined automatically if you do not declare it. If more than one return statement is specified, the types of all objects returned must be compatible in the target language. If a return statement contains a sequence of objects, the sequence is translated into an array. Implicit returns are recognized in some cases, but translations to explicit returns can be suppressed by using the deducereturn=false option. When necessary, an automatically generated return variable is used to store a return value.

Lists, Maple data structures of the type array, and rtables are translated to arrays in the target language. It is recommended that you declare the type and ranges for all arrays. In some target languages, arrays are reindexed to begin at index 0.

In this example, the defaulttype option sets the default type to integer and the output option specifies that a string is returned. In this case, the output is assigned to the variable s.

In this example, because Fortran 77 is not case-sensitive, the variable X is renamed to avoid a conflict with the variable x.

In this example, the optimize option is used to minimize the number of arithmetic operations called in the exported code. The default exported code would have recomputed a value for (3 - c * b + a * b), which appears many times. To avoid recomputing the value, common subexpressions are evaluated once and stored in variables so that other expressions can refer to the value.

In the following example, all of the parameters are assigned a floating-point type by default. The defaulttype option determines how to interpret variables that do not have a type.

Maple attempts to determine the types of variables that do not have a type automatically. The default type is assigned only to those variables that do not have a type after the automatic type deduction process. In the following example, the parameters y and z are assigned a floating-point type because they are in an expression involving the float variable x. Therefore, the default type, integer, is not assigned.

You can turn off the automatic type deduction process by setting the deducetypes option to false. In the following example, the parameters y and z are now assigned the default type.

You can turn off the explicit type coercion process by setting the coercetypes option to false.

You can control how types are assigned by specifying the parameter, local variable, and return types explicitly in procedures or by using the declare option with expressions.

All Maple input to the CodeGeneration translators is processed and converted to an inert intermediate form called intermediate code. The intermediate code is the basic object on which all CodeGeneration translators operate. For information about the intermediate code, refer to the CodeGeneration/General/IntermediateCodeStructure help page.

The names that appear in intermediate code expressions are part of the CodeGeneration:-Names subpackage.

Error and warning messages displayed from CodeGeneration package commands sometimes refer to the intermediate form of the Maple expression that triggered the message.

When determining the cause of an error message or writing and debugging custom language definitions, it is recommended that you determine the intermediate form of a Maple expression input. In general, you can determine the intermediate form by using the CodeGeneration:-IntermediateCode translator. However, because some aspects of the intermediate code are specific to the language to which you are translating, it may help to see the intermediate code for a specific translator. This can be done by setting the command infolevel[CodeGeneration] to a value greater than 3 and performing a translation.

The following example shows the intermediate code for the expression 2x^2-1. The first argument of the Scope structure is the name of a type table used internally during the translation process.

The CodeGeneration package is distributed with translators for several programming languages. In addition, you can define new translators to enable the CodeGeneration package to generate code for other languages. Tools for this task are available in the LanguageDefinition subpackage of CodeGeneration.

Custom translators can define a complete language, extend existing language definitions, overriding and extending only those language components that need to be changed.

To view a list of languages that are currently supported by the CodeGeneration package, and thus available for extending, use the CodeGeneration:-LanguageDefinition:-ListLanguages command.

As described previously, the CodeGeneration package first processes the Maple input and translates it to an intermediate form. This step is followed by the printing phase, which translates the intermediate form to a Maple string according to transformation rules specific to the target language.

For each name used in the intermediate form, there is a print handler procedure. During the printing phase, Maple traverses the intermediate form recursively. For each subexpression of the intermediate form, Maple invokes the print handler associated with that class of expressions.

This section explains the process of defining a translator for a target language.

For each CodeGeneration language definition, there is an associated Maple module called a Printer module, which contains language-specific print handlers and data. A Printer module has several functions, which set and reference language-specific printing data.

There are two ways to obtain a Printer module: the LanguageDefinition:-GenericPrinter() returns a generic Printer module containing no language-specific data, and the LanguageDefinition:-Get(language_name):-Printer command returns a copy of the Printer module used for a previously defined language language_name.

The most frequently used Printer package command is Print. When it is given a string, the Print command prints the string to a buffer. When given an intermediate-form expression, the Print command invokes the print handler appropriate for the expression. In this manner, Print recurses through the intermediate form until it is printed in its entirety to the buffer. At this point, the translation process is complete.

Table 14.3 lists the important Printer commands.  For a complete list and more detailed information, refer to the CodeGeneration/LanguageDefinition/Printer help page.

The following commands illustrate how data is stored and retrieved from a Printer module.

Within a language definition, the Printer module associated with the language definition can be referenced by the name Printer. Note: This applies to both of the language definition methods described in the next section.

There are two distinct methods of defining a language translator for use by the CodeGeneration package: using the LanguageDefinition:-Define command and creating a language definition module.

For simple languages or small extensions of existing languages, use the LanguageDefinition:-Define command. To create a translator that preprocesses or postprocesses the generated output, or makes frequent use of a utility function in translations, create a language definition module. The language definition module approach is used for all translators supplied with the CodeGeneration package.

The Define command takes a series of function call arguments f1, f2, ... where the command names are, for example, AddFunction, AddFunctions, AddOperator, AddPrintHandler, AddType, and SetLanguageAttribute.

These function calls accept identical syntax and perform the same actions as the Printer commands of the same name. That is, they define print handlers and other data specific to the language translation you are defining. For more information on these commands, refer to the CodeGeneration/LanguageDefinition/Printer help page.

The Define command automatically creates a Printer module for the language. You do not need to create one using the LanguageDefinition:-GenericPrinter or LanguageDefinition:-Get commands.

This example illustrates a C translator, in which the translated code uses a specialized library function mymult for multiplication instead of the built-in * operator.

Note that in the previous example, one of the arguments of the LanguageDefinition:-Define command is the function call AddPrintHandler, which takes a name and a procedure as arguments. The supplied procedure therefore prints any Product subexpression of the intermediate form. The call to Printer:-Print specifies that the translator uses the automatically generated Printer module.

A language definition module is a Maple module with the exports PrintTarget and Printer. The module exports must satisfy the following criteria.

The body of the module definition must contain a sequence of calls to Printer commands that define language-specific data and utility procedures.

Once defined, a language definition module can be added to to the set of languages recognized by the CodeGeneration package by using the CodeGeneration:-LanguageDefinition:-Add command.

When creating your language definition module, you must delay the evaluation of the module by using unevaluation quotes before adding it using the LanguageDefinition:-Add command. That is, the language definition module must be added as a module definition and not as a module.

The following example adds a definition module. Note the use of unevaluation quotes around the module definition to delay its evaluation.

After creating the language definition using either the LanguageDefinition:-Define or LanguageDefinition:-Add commands, translate your code to the new language using the CodeGeneration:-Translate command.

The following example demonstrates the use of a new translator. Compare the output of the Fortran command with that of the new translator.