JD Edwards EnterpriseOne Tools

Development Standards for Business Function Programming Guide

Release 8.98 Update 4

E14699-02

March 2011

JD Edwards EnterpriseOne Tools Development Standards for Business Function Programming Guide, Release 8.98 Update 4

E14699-02

Copyright © 2011, Oracle and/or its affiliates. All rights reserved.

This software and related documentation are provided under a license agreement containing restrictions on use and disclosure and are protected by intellectual property laws. Except as expressly permitted in your license agreement or allowed by law, you may not use, copy, reproduce, translate, broadcast, modify, license, transmit, distribute, exhibit, perform, publish, or display any part, in any form, or by any means. Reverse engineering, disassembly, or decompilation of this software, unless required by law for interoperability, is prohibited.

The information contained herein is subject to change without notice and is not warranted to be error-free. If you find any errors, please report them to us in writing.

If this is software or related documentation that is delivered to the U.S. Government or anyone licensing it on behalf of the U.S. Government, the following notice is applicable:

U.S. GOVERNMENT RIGHTS Programs, software, databases, and related documentation and technical data delivered to U.S. Government customers are "commercial computer software" or "commercial technical data" pursuant to the applicable Federal Acquisition Regulation and agency-specific supplemental regulations. As such, the use, duplication, disclosure, modification, and adaptation shall be subject to the restrictions and license terms set forth in the applicable Government contract, and, to the extent applicable by the terms of the Government contract, the additional rights set forth in FAR 52.227-19, Commercial Computer Software License (December 2007). Oracle America, Inc., 500 Oracle Parkway, Redwood City, CA 94065.

This software or hardware is developed for general use in a variety of information management applications. It is not developed or intended for use in any inherently dangerous applications, including applications that may create a risk of personal injury. If you use this software or hardware in dangerous applications, then you shall be responsible to take all appropriate fail-safe, backup, redundancy, and other measures to ensure its safe use. Oracle Corporation and its affiliates disclaim any liability for any damages caused by use of this software or hardware in dangerous applications.

Oracle and Java are registered trademarks of Oracle and/or its affiliates. Other names may be trademarks of their respective owners.

Intel and Intel Xeon are trademarks or registered trademarks of Intel Corporation. All SPARC trademarks are used under license and are trademarks or registered trademarks of SPARC International, Inc. AMD, Opteron, the AMD logo, and the AMD Opteron logo are trademarks or registered trademarks of Advanced Micro Devices. UNIX is a registered trademark licensed through X/Open Company, Ltd.

This software or hardware and documentation may provide access to or information on content, products, and services from third parties. Oracle Corporation and its affiliates are not responsible for and expressly disclaim all warranties of any kind with respect to third-party content, products, and services. Oracle Corporation and its affiliates will not be responsible for any loss, costs, or damages incurred due to your access to or use of third-party content, products, or services.

Contents

List of Figures

Preface

- Audience

- Documentation Accessibility

- Related Documents

- Conventions

1 Introduction to JD Edwards EnterpriseOne Tools Development Standards for Business Function Programming

- 1.1 Development Standards for Business Function Programming Overview

- 1.2 Development Standards for Business Function Programming Implementation

- 1.2.1 Business Function Programming Implementation Steps

2 Understanding Naming Conventions

- 2.1 Source and Header File Names

- 2.2 Function Names

- 2.3 Variable Names

- 2.3.1 Example: Hungarian Notation for Variable Names

- 2.4 Business Function Data Structure Names

3 Ensuring Readability

- 3.1 Understanding Readability

- 3.2 Maintaining the Source and Header Code Change Log

- 3.3 Inserting Comments

- 3.3.1 Example: Inserting Comments

- 3.4 Indenting Code

- 3.4.1 Example: Indenting Code

- 3.5 Formatting Compound Statements

- 3.5.1 Example: Formatting Compound Statements

- 3.5.2 Example: Using Braces to Clarify Flow

- 3.5.3 Example: Using Braces for Ease in Subsequent Modifications

- 3.5.4 Example: Handling Multiple Logical Expressions

4 Declaring and Initializing Variables and Data Structures

- 4.1 Understanding Variables and Data Structures

- 4.2 Using Define Statements

- 4.2.1 Example: #define in Source File

- 4.2.2 Example: #define in Header File

- 4.3 Using Typedef Statements

- 4.3.1 Example: Using Typedef for a User-Defined Data Structure

- 4.4 Creating Function Prototypes

- 4.4.1 Example: Creating a Business Function Prototype

- 4.4.2 Example: Creating an Internal Function Prototype

- 4.4.3 Example: Creating an External Business Function Definition

- 4.4.4 Example: Creating an Internal Function Definition

- 4.5 Initializing Variables

- 4.5.1 Example: Initializing Variables

- 4.6 Initializing Data Structures

- 4.6.1 Example: Using Memset to Reset the Data Structure to Null

- 4.7 Using Standard Variables

- 4.7.1 Using Flag Variables

- 4.7.2 Using Input and Output Parameters

- 4.7.3 Using Fetch Variables

- 4.7.3.1 Example: Using Standard Variables

5 Applying General Coding Guidelines

- 5.1 Using Function Calls

- 5.1.1 Calling an External Business Function

- 5.1.1.1 Example: Calling an External Business Function

- 5.1.2 Calling an Internal Business Function

- 5.1.2.1 Example: Calling an Internal Business Function with No Return Value

- 5.1.2.2 Example: Calling an Internal Business Function with a Return Value

- 5.2 Passing Pointers between Business Functions

- 5.2.1 Storing an Address in an Array

- 5.2.1.1 Example: Storing an Address in an Array

- 5.2.2 Retrieving an Address from an Array

- 5.2.2.1 Example: Retrieving an Address from an Array

- 5.2.3 Removing an Address from an Array

- 5.2.3.1 Example: Removing an Address from an Array

- 5.3 Allocating and Releasing Memory

- 5.3.1 Example: Allocating and Releasing Memory within a Business Function

- 5.4 Using hRequest and hUser

- 5.5 Typecasting

- 5.6 Comparison Testing

- 5.6.1 Example: Comparison Test

- 5.6.2 Example: Creating TRUE or FALSE Test Comparison that Uses Boolean Logic

- 5.7 Copying Strings with jdeStrcpy or jdeStrncpy

- 5.8 Using the Function Clean Up Area

- 5.8.1 Example: Using the Function Clean Up Area to Release Memory

- 5.9 Inserting Function Exit Points

- 5.9.1 Example: Inserting an Exit Point in a Function

- 5.10 Terminating a Function

6 Coding for Portability

- 6.1 Portability Concepts

- 6.2 Portability Guidelines

- 6.3 Preventing Common Server Build Errors and Warnings

- 6.3.1 Comments within Comments

- 6.3.1.1 Example: C Comments that Comply with the ANSI Standard

- 6.3.1.2 Example: C Comments that Comply with the ANSI Standard

- 6.3.1.3 Example: Comments within Comments Cause Problems on Different Servers

- 6.3.2 New Line Character at the End of a Business Function

- 6.3.3 Use of Null Character

- 6.3.3.1 Example: Use of NULL Character

- 6.3.4 Lowercase Letters in Include Statements

- 6.3.4.1 Example: Use of Lowercase Letters in Include Statements

- 6.3.5 Initialized Variables that are Not Referenced

7 Understanding JD Edwards EnterpriseOne Defined Structures

- 7.1 MATH_NUMERIC Data Type

- 7.2 JDEDATE Data Type

- 7.2.1 Using Memcpy to Assign JDEDATE Variables

- 7.2.2 JDEDATECopy

8 Implementing Error Messages

- 8.1 Understanding Error Messages

- 8.2 Inserting Parameters for Error Messages in lpDS

- 8.2.1 Example: Parameters in lpDS for an Error Message

- 8.3 Initializing Behavior Errors

- 8.3.1 Example: Initialize Behavior Error

- 8.4 Using Text Substitution to Display Specific Error Messages

- 8.4.1 Example: Text Substitution in an Error Message

- 8.5 Mapping Data Structure Errors with jdeCallObject

9 Understanding Data Dictionary Triggers

- 9.1 Data Dictionary Triggers

10 Understanding Unicode Compliance Standards

- 10.1 Unicode Compliance Standards

- 10.2 Unicode String Functions

- 10.2.1 Example: Using Unicode String Functions

- 10.3 Unicode Memory Functions

- 10.3.1 Example: Using jdeMemset when Setting Characters to Values other than NULL

- 10.4 Pointer Arithmetic

- 10.5 Offsets

- 10.6 MATH_NUMERIC APIs

- 10.7 Third-Party APIs

- 10.7.1 Example: Third-Party API

- 10.8 Flat-File APIs

- 10.8.1 Example: Flat-File APIs

11 Understanding Standard Header and Source Files

- 11.1 Standard Header

- 11.1.1 Business Function Name and Description

- 11.1.2 Copyright Notice

- 11.1.3 Header Definition for a Business Function

- 11.1.4 Table Header Inclusions

- 11.1.5 External Business Function Header Inclusions

- 11.1.6 Global Definitions

- 11.1.7 Structure Definitions

- 11.1.8 DS Template Type Definitions

- 11.1.9 Source Preprocessing Definitions

- 11.1.10 Business Function Prototypes

- 11.1.11 Internal Function Prototypes

- 11.2 Standard Source

- 11.2.1 Business Function Name and Description

- 11.2.2 Copyright Notice

- 11.2.3 Notes

- 11.2.4 Global Definitions

- 11.2.5 Header File for Associated Business Function

- 11.2.6 Business Function Header

- 11.2.7 Variable Declarations

- 11.2.8 Declare Structures

- 11.2.9 Pointers

- 11.2.10 Check for NULL Pointers

- 11.2.11 Set Pointers

- 11.2.12 Main Processing

- 11.2.13 Function Clean Up

- 11.2.14 Internal Function Comment Block

Glossary

Index

List of Figures

- 10-1 Example 1 of Unicode Pointer Arithmetic

- 10-2 Example 2 of Unicode Pointer Arithmetic

- 10-3 Example 3 of Pointer Arithmetic

Preface

Welcome to the JD Edwards EnterpriseOne Tools Development Standards for Business Function Programming Guide.

Audience

This guide is intended for developers and technical consultants who are responsible for creating and modifying business functions.

This guide assumes you have a working knowledge of the following:

• The principles and customary practices of your business area.

• C++ programing.

Documentation Accessibility

For information about Oracle's commitment to accessibility, visit the Oracle Accessibility Program website at http://www.oracle.com/us/corporate/accessibility/index.html.

Access to Oracle Support

Oracle customers have access to electronic support through My Oracle Support. For information, visit http://www.oracle.com/support/contact.html or visit http://www.oracle.com/accessibility/support.html if you are hearing impaired.

Related Documents

You can access related documents from the JD Edwards EnterpriseOne Release Documentation Overview pages on My Oracle Support. Access the main documentation overview page by searching for the document ID, which is 876932.1, or by using this link:

https://support.oracle.com/CSP/main/article?cmd=show&type=NOT&id=876932.1

To navigate to this page from the My Oracle Support home page, click the Knowledge tab, and then click the Tools and Training menu, JD Edwards EnterpriseOne, Welcome Center, Release Information Overview.

This guide contains references to server configuration settings that JD Edwards EnterpriseOne stores in configuration files (such as jde.ini, jas.ini, jdbj.ini, jdelog.properties, and so on). Beginning with the JD Edwards EnterpriseOne Tools Release 8.97, it is highly recommended that you only access and manage these settings for the supported server types using the Server Manager program. See the Server Manager Guide on My Oracle Support.

Conventions

The following text conventions are used in this document:

Convention

Meaning

Bold

Indicates field values.

Italics

Indicates emphasis and JD Edwards EnterpriseOne or other book-length publication titles.

Monospace

Indicates a JD Edwards EnterpriseOne program, other code example, or URL.

1 Introduction to JD Edwards EnterpriseOne Tools Development Standards for Business Function Programming

This chapter contains the following topics:

- Section 1.1, "Development Standards for Business Function Programming Overview"

- Section 1.2, "Development Standards for Business Function Programming Implementation"

1.1 Development Standards for Business Function Programming Overview

Business Function Programming is an integral part of Oracle's JD Edwards EnterpriseOne tool set. Application developers can attach custom functionality to application and batch processing events by using business functions. You program business functions are programmed in C code, discussed in this guide, or as Named Event Rules.

1.2 Development Standards for Business Function Programming Implementation

This section provides an overview of the steps that are required to implement Development Standards for Business Function Programming.

In the planning phase of your implementation, take advantage of all JD Edwards EnterpriseOne sources of information, including the installation guides and troubleshooting information.

1.2.1 Business Function Programming Implementation Steps

This table lists the steps for JD Edwards EnterpriseOne Tools Business Function Programming implementation.

- Set up default project in OMW.
See "Understanding JD Edwards EnterpriseOne OMW Configuration" in the JD Edwards EnterpriseOne Tools Object Management Workbench Guide.

- Configure OMW transfer activity rules and allowed actions.
See "Understanding JD Edwards EnterpriseOne OMW Configuration" in the JD Edwards EnterpriseOne Tools Object Management Workbench Guide.

- Set up default location and printers.
See JD Edwards EnterpriseOne Tools Development Tools: Report Printing Administration Technologies Guide.

2 Understanding Naming Conventions

This chapter contains the following topics:

- Section 2.1, "Source and Header File Names"

- Section 2.2, "Function Names"

- Section 2.3, "Variable Names"

- Section 2.4, "Business Function Data Structure Names"

2.1 Source and Header File Names

Source and header file names can be a maximum of 8 characters and should be formatted as bxxyyyy, where:

- b = BSFN object

- xx (second two digits) = The system code, such as:

- 01 = Address Book

- 04 = Accounts Payable

- yyyyy (the last five digits) = A sequential number for the system code, such as:

- 00001 = The first source or header file for the system code

- 00002 = The second source or header file for the system code

Both the C source and the accompanying header file should have the same name.

This table shows examples of this naming convention:

System

System Code

Source Number

Source File

Header File

Address Book

01

10

b0100010.c

b0100010.h

Accounts Receivable

04

58

b0400058.c

b0400058.h

General Ledger

09

2457

b0902457.c

b0902457.h

2.2 Function Names

An internal function can be a maximum of 42 characters and should be formatted as Ixxxxxx_a, where:

- I = An internal function

- xxxxxx = The source file name

- a = The function description
Function descriptions can be up to 32 characters in length, and must not contain spaces. Be as descriptive as possible and capitalize the first letter of each word, such as ValidateTransactionCurrencyCode. When possible use the major table name or purpose of the function.

An example of a Function Name is I4100040_CompareDate

Note:
Do not use an underscore after I.

2.3 Variable Names

Variables are storage places in a program and can contain numbers and strings. Variables are stored in the computer's memory. Variables are used with keywords and functions, such as char and MATH_NUMERIC, and must be declared at the beginning of the program.

A variable name can be up to 32 characters in length. Be as descriptive as possible and capitalize the first letter of each word.

You must use Hungarian prefix notation for all variable names, as shown in this table:

Prefix

Description

c

JCHAR

sz

NULL-terminated JCHAR string

z

ZCHAR

zz

NULL-terminated ZCHAR string

n

short

l

long

b

Boolean

mn

MATH_NUMERIC

jd

JDEDATE

lp

long pointer

i

integer

by

byte

ul

unsigned long (identifier)

us

unsigned Short

ds

data structures

h

handle

e

enumerated types

id

id long integer, JDE data type for returns

ut

JDEUTIME

sz

VARCHAR

2.3.1 Example: Hungarian Notation for Variable Names

These variable names use Hungarian notation:

Variable

Description

JCHAR

cPaymentRecieved;

JCHAR [ ]

szCompanyNumber = _J(00000);

short

nLoopCounter;

long int

lTaxConstant;

BOOL

bIsDateValid;

MATH_NUMERIC

mnAddressNumber;

JDEDATE

jdGLDate;

LPMATH_NUMERIC

lpAddressNumber;

int

iCounter;

byte

byOffsetValue;

unsigned long

ulFunctionStatus;

D0500575A

dsInputParameters;

JDEDB_RESULT

idJDEDBResult;

2.4 Business Function Data Structure Names

The data structure for business function event rules and business functions should be formatted as DxxyyyyA, where:

- D = Data structure

- xx (second two digits) = The system code, such as

- 01 = Address Book

- 02 = Accounts Payable

- yyyy = A next number (the numbering assignments follow current procedures in the respective application groups)

- A = An alphabetical character (such as A, B, C and so on) placed at the end of the data structure name to indicate that a function has multiple data structures
Even if a function has only one data structure, you should include the A in the name.

An example of a Business Function Data Structure Name is D050575A.

3 Ensuring Readability

This chapter contains the following topics:

- Section 3.1, "Understanding Readability"

- Section 3.2, "Maintaining the Source and Header Code Change Log"

- Section 3.3, "Inserting Comments"

- Section 3.4, "Indenting Code"

- Section 3.5, "Formatting Compound Statements"

3.1 Understanding Readability

Readable code is easier to debug and maintain. You can make code more readable by maintaining the change log, inserting comments, indenting code, and formatting compound statements.

3.2 Maintaining the Source and Header Code Change Log

You must note any code changes that you make to the standard source and header for a business function. Include this information:

- SAR - the SAR number

- Date - the date of the change

- Initials - the programmer's initials

- Comment - the reason for the change

3.3 Inserting Comments

Insert comments that describe the purpose of the business function and your intended approach. Using comments will make future maintenance and enhancement of the function easier.

Use this checklist for inserting comments:

- Always use the /*comment */ style. The use of // comments is not portable.

- Precede and align comments with the statements they describe.

- Comments should never be more that 80 characters wide.

3.3.1 Example: Inserting Comments

This example shows the correct way to insert block and inline comments into code:

/*----------------------------------------------------------
* Comment blocks need to have separating lines between
* the text description. The separator can be a
* dash '-' or an asterisk '*'
*----------------------------------------------------------*/
if ( statement )
{
statements
} /* inline comments indicate the meaning of one statement */
/*----------------------------------------------------------
* Comments should be used in all segments of the source
* code. The original programmer may not be the programmer
* maintaining the code in the future which makes this a
* crucial step in the development process.
*----------------------------------------------------------*/
/************************************************************
* Function Clean Up
************************************************************/

3.4 Indenting Code

Any statements executed inside a block of code should be indented within that block of code. Standard indentation is three spaces.

Note:
Set up the environment for the editor you are using to set tab stops at 3 and turn the tab character display off. Then, each time you press the Tab key, three spaces are inserted rather than the tab character. Select auto-indentation.

3.4.1 Example: Indenting Code

This the standard method to indent code:

function block
{
if ( nJDEDBReturn == JDEDB_PASSED )
{
CallSomeFunction( nParameter1, szParameter2 );
CallAnotherFunction( lSomeNumber );
while( FunctionWithBooleanReturn() )
{
CallYetAnotherFunction( cStatusCode );
}
}
}

3.5 Formatting Compound Statements

Compound statements are statements followed by one or more statements enclosed with braces. A function block is an obvious example of a compound statement. Control statements (while, for) and selection statements (if, switch) are also examples of compound statements.

Omitting braces is a common C coding practice when only one statement follows a control or selection statement. However, you must use braces for all compound statements for these reasons:

- The absence of braces can cause errors.

- Braces ensure that all compound statements are treated the same way.

- In the case of nested compound statements, the use of braces clarifies the statements that belong to a particular code block.

- Braces make subsequent modifications easier.

Refer to these guidelines when formatting compound statements:

- Always have one statement per line within a compound statement.

- Always use braces to contain the statements that follow a control statement or a selection statement.

- Braces should be aligned with the initial control or selection statement.

- Logical expressions evaluated within a control or selection statement should be broken up across multiple lines if they do not fit on one line. When breaking up multiple logical expressions, do not begin a new line with the logical operator; the logical operator must remain on the preceding line.

- When evaluating multiple logical expressions, use parentheses to explicitly indicate precedence.

- Never declare variables within a compound statement, except function blocks.

- Use braces for all compound statements.

- Place each opening or closing brace, { or }, on a separate line.

3.5.1 Example: Formatting Compound Statements

This example shows how to format compound statements for ease of use and to prevent mistakes:

/*
* Do the Issues Edit Line if the process edits is either
* blank or set to SKIP_COMPLETIONS. The process edits is
* set to SKIP_COMPLETIONS if Hours and Quantities is in
* interactive mode and Completions is Blind in P31123.
*/
if ((dsWorkCache.PO_cIssuesBlindExecution == _J('1')) &&
((dsCache.cPayPointCode == _J('M'))      ||
(dsCache.cPayPointCode == _J('B')))       &&
(lpDS->cProcessEdits != ONLY_COMPLETIONS))
{
/* Process the Pay Point line for Material Issues */
idReturnCode = I3101060_BlindIssuesEditLine(&dsInternal,
&dsCache,
&dsWorkCache);
}

3.5.2 Example: Using Braces to Clarify Flow

This example shows the use of braces to clarify the flow and prevent mistakes:

if(idJDBReturn != JDEDB_PASSED)
{
/* If not add mode, record must exist */
if ((lpdsInternal->cActionCode != ADD_MODE) &&
(lpdsInternal->cActionCode != ATTACH_MODE))
{
/* Issue Error 0002 - Work Order number invalid */
jdeStrncpy((JCHAR*)(lpdsInternal->szErrorMessageID),
(const JCHAR*)_J(0002),
DIM(lpdsInternal->szErrorMessageID)-1);
lpdsInternal->idFieldID = IDERRmnOrderNumber_15;
idReturnCode = ER_ERROR;
}
}
else
{
/* If in add mode and the record exists, issue error and exit */
if (lpdsInternal->cActionCode == ADD_MODE)
{
/* Issue Error 0002 - Work Order number invalid */
jdeStrncpy((JCHAR*)(lpdsInternal->szErrorMessageID),
(const JCHAR*)_J(0002),
DIM(lpdsInternal->szErrorMessageID)-1);
lpdsInternal->idFieldID = IDERRmnOrderNumber_15;
idReturnCode = ER_ERROR;
}
else
{
/*
* Set flag used in determining if the F4801 record should be sent
* in to the modules
*/
lpdsInternal->cF4801Retrieved = _J('1');
}
}

3.5.3 Example: Using Braces for Ease in Subsequent Modifications

The use of braces prevents mistakes when the code is later modified. Consider this example. The original code contains a test to see if the number of lines is less than a predefined limit. As intended, the return value is assigned a certain value if the number of lines is greater than the maximum. Later, someone decides that an error message should be issued in addition to assigning a certain return value. The intent is for both statements to be executed only if the number of lines is greater than the maximum. Instead, idReturn will be set to ER_ERROR regardless of the value of nLines. If braces were used originally, this mistake would have been avoided.

ORIGINAL

if (nLines > MAX_LINES)
idReturn = ER_ERROR;

MODIFIED

if (nLines > MAX_LINES)
jdeErrorSet (lpBhvrCom, lpVoid,
(ID) 0, _J(4353), (LPVOID) NULL);
idReturn = ER_ERROR;

STANDARD ORIGINAL

if (nLines > MAX_LINES)
{
idReturn = ER_ERROR;
}

STANDARD MODIFIED

if (nLines > MAX_LINES)
{
jdeErrorSet (lpBhvrCom, lpVoid,
(ID) 0, _J(4363), (LPVOID) NULL);
idReturn = ER_ERROR;
}

3.5.4 Example: Handling Multiple Logical Expressions

This example shows how to handle multiple logical expressions:

while ( (lWorkArray[elWorkX] < lWorkArray[elWorkMAX]) &&
(lWorkArray[elWorkX] < lWorkArray[elWorkCDAYS]) &&
(idReturnCode == ER_SUCCESS))

{
statements
}

4 Declaring and Initializing Variables and Data Structures

This chapter contains the following topics:

- Section 4.1, "Understanding Variables and Data Structures"

- Section 4.2, "Using Define Statements"

- Section 4.3, "Using Typedef Statements"

- Section 4.4, "Creating Function Prototypes"

- Section 4.5, "Initializing Variables"

- Section 4.6, "Initializing Data Structures"

- Section 4.7, "Using Standard Variables"

4.1 Understanding Variables and Data Structures

Variables and data structures must be defined and initialized before they can be used to store data. This chapter describes how to declare and initialize them. It includes topics on using define statements, using typedef, creating function prototypes, initializing variables, initializing data structures, and using standard variables.

4.2 Using Define Statements

A define statement is a directive that sets up constants at the beginning of the program. A define statement always begins with a pound sign (#). All business functions include the system header file: jde.h. System-wide define statements are included in the system header file.

If you need define statements for a specific function, include the define statement in uppercase letters within the source file for the function whenever possible. The statement should directly follow the header file inclusion statement.

Usually, you should place define statements in the source file, not the header file. When placed in the header file, you can redefine the same constant with different values, causing unexpected results. However, rare cases exist when it is necessary to place a define statement in the function header file. In these cases, precede the definition name with the business function name to ensure uniqueness.

4.2.1 Example: #define in Source File

This example includes define statements within a business function source file:

/*************************************************************
* Notes
*************************************************************/

#include <bxxxxxxx.h>

/*************************************************************
* Global Definitions
*************************************************************/
#define CACHE_GET            '1'
#define CACHE_ADD            '2'
#define CACHE_UPDATE         '3'
#define CACHE_DELETE         '4'

4.2.2 Example: #define in Header File

This example includes define statements within a business function header:

/**********************************************************
* External Business Function Header Inclusions
**********************************************************/

#include <bxxxxxxx.h>

/**********************************************************
* Global definitions
**********************************************************/
#define BXXXXXXX_CACHE_GET         '1'
#define BXXXXXXX_CACHE_ADD         '2'
#define BXXXXXXX_CACHE_UPDATE      '3'
#define BXXXXXXX_CACHE_DELETE      '4'

4.3 Using Typedef Statements

When using typedef statements, always name the object of the typedef statement using a descriptive, uppercase format. If you are using a typedef statement for data structures, remember to include the name of the business function in the name of the typedef to make it unique. See the example for using a typedef statement for a data structure.

4.3.1 Example: Using Typedef for a User-Defined Data Structure

This is an example of a user-defined data structure:

/**************************************************************
* Structure Definitions
**************************************************************/

typedef struct
{
HUSER         hUser;           /** User handle **/
HREQUEST      hRequestF0901;   /** File Pointer to the
* Account Master **/
DSD0051       dsData;          /** X0051 - F0902 Retrieval **/
int           iFromYear;       /** Internal Variables **/
BOOL          bProcessed;
MATH_NUMERIC  mnCalculatedAmount;
JCHAR         szSummaryJob[13];
JDEDATE       jdStartPeriodDate;
} DSX51013_INFO, *LPDSX51013_INFO;

4.4 Creating Function Prototypes

Refer to these guidelines when defining function prototypes:

- Always place function prototypes in the header file of the business function in the appropriate prototype section.

- Include function definitions in the source file of the business function, preceded by a function header.

- Ensure that function names follow the naming convention defined in this guide.

- Ensure that variable names in the parameter list follow the naming convention defined in this guide.

- List the variable names of the parameters along with the data types in the function prototype.

- List one parameter per line so that the parameters are aligned in a single column.

- Do not allow the parameter list to extend beyond 80 characters in the function definition. If the parameter list must be broken up, the data type and variable name must stay together. Align multiple-line parameter lists with the first parameter.

- Include a return type for every function. If a function does not return a value, use the keyword void as the return type.

- Use the keyword void in place of the parameter list if nothing is passed to the function.

4.4.1 Example: Creating a Business Function Prototype

This is an example of a standard business function prototype:

/*****************************************************************
* Business Function: BusinessFunctionName
*
*    Description: Business Function Name
*
*     Parameters:
*      LPBHVRCOM  lpBhvrCom Business Function Communications
*      LPVOID   lpVoid  Void Parameter - DO NOT USE!
*    LPDSD51013 lpDS   Parameter Data Structure Pointer
*
*****************************************************************/

JDEBFRTN (ID) JDEBFWINAPI BusinessFunctionName (LPBHVRCOM  lpBhvrCom,
LPVOID     lpVoid,
LPDSXXXXXX lpDS)

4.4.2 Example: Creating an Internal Function Prototype

This is an example of a standard internal function prototype:

Type XXXXXXXX_AAAAAAAA( parameter list ... );

type     : Function return value
XXXXXXXX : Unique source file name
AAAAAAAA : Function Name

4.4.3 Example: Creating an External Business Function Definition

This is an example of a standard external business function definition:

/*
*  see sample source for standard business function heading
*/
JDEBFRTN (ID) JDEBFWINAPI GetAddressBookDescription(LPBHVRCOM  lpBhvrCom,
LPVOID     lpVoid,
LPDSNNNNNN lpDS)
{
ID idReturn = ER_SUCCESS;
/*--------------------------------------------------------------
* business function code
*/
return idReturn;
}

4.4.4 Example: Creating an Internal Function Definition

This is an example of a standard internal function definition:

/*-----------------------------------------------------------------------
*  see sample source for standard function header
*/
void I4100040_GetSupervisorManagerDefault( LPBHVRCOM lpBhvrCom,
LPSTR lpszCostCenterIn,
LPSTR lpszManagerOut,
LPSTR lpszSupervisorOut )
/*-----------------------------------------------------------------------
* Note: b4100040 is the source file name
*/
{
/*
* internal function code
*/
}

4.5 Initializing Variables

Variables store information in memory that is used by the program. Variables can store strings of text and numbers.

When you declare a variable, you should also initialize it. Two types of variable initialization exist: explicit and implicit. Variables are explicitly initialized if they are assigned a value in the declaration statement. Implicit initialization occurs when variables are assigned a value during processing.

This information covers standards for declaring and initializing variables in business functions and includes an example of standard formats.

Use these guidelines when declaring and initializing variables:

- Declare variables using this format:

datatype variable name = initial value; /* descriptive comment*/

- Declare all variables used within business functions and internal functions at the beginning of the function. Although C allows you to declare variables within compound statement blocks, this standard requires all variables used within a function to be declared at the beginning of the function block.

- Declare only one variable per line, even if multiple variables of the same type exist. Indent each line three spaces and left align the data type of each declaration with all other variable declarations. Align the first character of each variable name (variable name in the preceding format example) with variable names in all other declarations.

- Use the naming conventions set forth in this guide. When initializing variables, the initial value is optional depending on the data type of the variable. Generally, all variables should be explicitly initialized in their declaration.

- The descriptive comment is optional. In most cases, variable names are descriptive enough to indicate the use of the variable. However, provide a comment if further description is appropriate or if an initial value is unusual.

- Left align all comments.

- Data structures should be initialized to zero using the memset function immediately after the declaration section.

- Some Application Program Interfaces (APIs), such as the JDB ODBC API, provide initialization routines. In this case, the variables intended for use with the API should be initialized with the API routines.

- Always initialize pointers to NULL and include an appropriate type call at the declaration line.

- Initialize all variables, except data structures, in the declaration.

- Initialize all declared data structures, MATH_NUMERIC, and JDEDATE to NULL.

- Ensure that the byte size of the variable matches the size of the data structure you want to store.

4.5.1 Example: Initializing Variables

This example shows how to initialize variables:

JDEBFRTN (ID) JDEBFWINAPI F0902GLDateSensitiveRetrieval
(LPBHVRCOM   lpBhvrCom,
LPVOID     lpVoid,
LPDSD0051   lpDS)
/****************************************************************
* Variable declarations
***************************************************************/
ID             idReturn      = ER_SUCCESS;
JDEDB_RESULT   eJDEDBResult  = JDEDB_PASSED;
long           lDateDiff     = 0L;
BOOL           bAddF0911Flag = TRUE;
MATH_NUMERIC   mnPeriod      = {0};

/****************************************************************
* Declare structures
***************************************************************/
HUSER          hUser         = (HUSER) NULL;
HREQUEST       hRequestF0901 = (HREQUEST) NULL;
DSD5100016     dsDate        = {0};
JDEDATE        jdMidDate     = {0};

/****************************************************************
* Pointers
***************************************************************/
LPX0051_DSTABLES lpdsTables = (LPX0051_DSTABLES) 0L;

/****************************************************************
* Check for NULL pointers
**************************************************************/
if ((lpBhvrCom == (LPBHVRCOM) NULL) ||
(lpVoid    == (LPVOID)    NULL) ||
(lpDS      == (LPDSD0051)   NULL))
{
jdeErrorSet (lpBhvrCom, lpVoid, (ID) 0,
_J(4363), (LPVOID) NULL);
return ER_ERROR;
}

/**************************************************************
* Main Processing
**************************************************************/
eJDEDBResult = JDB_InitBhvr ((void*)lpBhvrCom,
&hUser,
(JCHAR *) NULL,
JDEDB_COMMIT_AUTO);

memcopy ((void*)) &dsDate.jdPeriodEndDate,
(const void*) &lpDS->jdGLDate, sizeof(JDEDATE));

4.6 Initializing Data Structures

When writing to the table, the table recognizes these default values:

- Space-NULL if string is blank

- 0 value if math numeric is 0

- 0 JDEDATE if date is blank

- Space if character is blank

Always memset to NULL on the data structure that is passed to another business function to update a table or fetch a table.

4.6.1 Example: Using Memset to Reset the Data Structure to Null

This example resets the data structure to NULL when initializing the data structure:

bOpenTable = B5100001_F5108SetUp( lpBhvrCom, lpVoid,
lphUser, &hRequestF5108);

if ( bOpenTable )
{
memset( (void *)(&dsF5108Key), 0x00, sizeof(KEY1_F5108) );
jdeStrcpy( (JCHAR*) dsF5108Key.mdmcu,
(const JCHAR*) lpDS->szBusinessUnit );
memset( (void *)(&dsF5108), 0x00, sizeof(F5108) );

jdeStrcpy( (JCHAR*) dsF5108.mdmcu,
(const JCHAR*) lpDS->szBusinessUnit );
MathCopy(&dsF5108.mdbsct, &mnCentury);
MathCopy(&dsF5108.mdbsfy, &mnYear);
MathCopy(&dsF5108.mdbtct, &mnCentury);
MathCopy(&dsF5108.mdbtfy, &mnYear);
eJDEDBResult = JDB_InsertTable( hRequestF5108,
ID_F5108,
(ID)(0),
(void *) (&dsF5108) );
}

4.7 Using Standard Variables

This section discusses how to:

- Use flag variables.

- Use input and output parameters.

- Use fetch variables.

4.7.1 Using Flag Variables

When creating flag variables, use these guidelines:

- Any true-or-false flag used must be a Boolean type (BOOL).

- Name the flag variable to answer a question of TRUE or FALSE.

These are examples of flag variables, with a brief description of how each is used:

Flag Variable

Description

bIsMemoryAllocated

Apply to memory allocation

bIsLinkListEmpty

Link List

4.7.2 Using Input and Output Parameters

Business functions frequently return error codes and pointers. The input and output parameters in the business function data structure should be named as follows:

Input and Output Parameter

Description

cReturnPointer

When allocating memory and returning GENLNG.

cErrorCode

Based on cCallType, cErrorCode returns a 1 when it fails or a 0 when it succeeds.

cSuppressErrorMessage

If the value is 1, do not display error message using jdeErrorSet(...). If the value is 0, display the error.

szErrorMessageId

If an error occurs, return an error message ID (value). Otherwise, return four spaces.

4.7.3 Using Fetch Variables

Use fetch variables to retrieve and return specific information, such as a result; to define the table ID; and to specify the number of keys to use in a fetch.

Fetch Variable

Description

idJDEDBResult

APIs or JD Edwards EnterpriseOne functions, such as JDEDB_RESULT

idReturnValue

Business function return value, such as ER_WARNING or ER_ERROR

idTableXXXXID

Where XXXX is the table name, such as F4101 and F41021, the variable used to define the Table ID.

idIndexXXXXID

Where XXXX is the table name, such as F4101 or F41021, the variable used to define the Index ID of a table.

usXXXXNumColToFetch

Where XXXX is the table name, such as F4101 and F41021, the number of the column to fetch. Do not put the literal value in the API functions as the parameter.

usXXXXNumOfKeys

Where XXXX is the table name, such as F4101 and F41021, the number of keys to use in the fetch.

4.7.3.1 Example: Using Standard Variables

This example illustrates the use of standard variables:

/****************************************************************
* Variable declarations
**************************************************************/
ID      idJDEDBResult  = JDEDB_PASSED;
ID      idTableF0901   = ID_F0901;
ID      idIndexF0901   = ID_F0901_ACCOUNT_ID;
ID      idFetchCol[]   = { ID_CO, ID_AID, ID_MCU, ID_OBJ,
ID_SUB, ID_LDA, ID_CCT };
ushort    usNumColToFetch = 7;
ushort    usNumOfKeys     = 1;

/***************************************************************
* Structure declarations
****************************************************************/
KEY3_F0901     dsF0901Key = {0}
DSX51013_F0901 dsF0901 = {0}

/***************************************************************
* Main Processing
***************************************************************/
/** Open the table, if it is not open **/
if ((*lpdsInfo->lphRequestF0901) == (HREQUEST) NULL)
{
if ( (*lpdsInfo->lphUser) == (HUSER) 0L )
{
idJDEDBResult = JDB_InitBhvr ((void*)lpBhvrCom,
&lpdsInfo->lphUser,
(JCHAR *) NULL,
JDEDB_COMMIT_AUTO);
}
if (idJDEDBResult == JDEDB_PASSED)
{
idJDEDBResult = JDB_OpenTable( (*lpdsInfo->lphUser),
idTableF0901,
idIndexF0901,
(LPID)(idFetchCol),
(ushort)(usNumColFetch),
(JCHAR *) NULL,
&lpdsInfo->hRequestF0901 );
}
}
/** Retrieve Account Master - AID only sent **/
if (idJDEDBResult == JDEDB_PASSED)
{
/** Set Key and Fetch Record **/
memset( (void *)(&dsF0901Key),
(int) _J('\0'), sizeof(KEY3_F0901) );
jdeStrcpy ((char *) dsF0901Key.gmaid,
(const JCHAR*) lpDS->szAccountID );
idJDEDBResult = JDB_FetchKeyed ( lpdsInfo->hRequestF0901,
idIndexF0901,
(void *)(&dsF0901Key),
(short)(1),
(void *)(&dsF0901),
(int)(FALSE) );
/** Check for F0901 Record **/
if (eJDEDBResult == JDEDB_PASSED)
{
statement
}
}

5 Applying General Coding Guidelines

This chapter contains the following topics:

- Section 5.1, "Using Function Calls"

- Section 5.2, "Passing Pointers between Business Functions"

- Section 5.3, "Allocating and Releasing Memory"

- Section 5.4, "Using hRequest and hUser"

- Section 5.5, "Typecasting"

- Section 5.6, "Comparison Testing"

- Section 5.7, "Copying Strings with jdeStrcpy or jdeStrncpy"

- Section 5.8, "Using the Function Clean Up Area"

- Section 5.9, "Inserting Function Exit Points"

- Section 5.10, "Terminating a Function"

5.1 Using Function Calls

Reuse of existing functions through a function call prevents duplicate code. Refer to these guidelines when using function calls:

- Always put a comma between each parameter. Optionally, you can add a space for readability.

- If the function has a return value, always check the return of the function for errors or a valid value.

- Use jdeCallObject to call another business function.

- When calling functions with long parameter lists, the function call should not be wider than 80 characters.
Break the parameter list into one or more lines, aligning the first parameter of proceeding lines with the first parameter in the parameter list.

- Make sure the data types of the parameters match the function prototype.
When intentionally passing variables with data types that do not match the prototype, explicitly cast the parameters to the correct data type.

5.1.1 Calling an External Business Function

Use jdeCallObject to call an external business function defined in the Object Management Workbench. Include the header file for the external business function that contains the prototype and data structure definition. It is good practice to check the value of the return code.

5.1.1.1 Example: Calling an External Business Function

This example calls an external business function:

/*-----------------------------------------------------------
*
* Retrieve account master information
*
*----------------------------------------------------------*/
idReturnCode = jdeCallObject(_J("ValidateAccountNumber),
NULL,
lpBhvrCom,
lpVoid,
(void*) &dsValidateAccount,
(CALLMAP*) NULL,
(int) 0,
(JCHAR*) NULL,
(JCHAR*) NULL,
(int) 0 );
if ( idReturnCode == ER_SUCCESS )
{
statement;
}

5.1.2 Calling an Internal Business Function

You can access internal business functions (internal C functions) within the same source file.

You may create modular subroutines that can be accessed from multiple source files. Use CALLIBF(fcn(parm1,parm2)) andCALLIBFRET(ret,fcn(parm1,parm2)) to access internal business functions within a different source file but within the same DLL. Use CALLIBF to call an internal business function with no return value. Use CALLIBFRET to call an internal business function with a return value. Both CALLIBF and CALLIFBRET can call internal business functions with any type or number of parameters.

CALLIBF and CALLIBFRET can only call internal functions within the same business function DLL. They cannot call functions in other business function DLLs. For example, if the internal function intFcn123() is in B550001.C, which is in the CALLBSFN.DLL, you cannot called it with CALLIBF or CALLIBFRET from a business function in CDIST.DLL.

To use CALLIBF or CALLIBFRET for an internal business function, the business function must have its prototype in the business function header. If you do not want other modules calling the internal business function, place the prototype in the C file, not the header file.

Calling internal business functions has several advantages over external business functions. First, they do not have the jdeCallObject performance overhead of checking OCM mapping and possibly executing the function remotely. A called function always executes in the same process from where it was called. Second, the parameters are not restricted to JD Edwards EnterpriseOne data dictionary data types. Any valid C data type, including pointers, may be passed in and out of internal functions.

5.1.2.1 Example: Calling an Internal Business Function with No Return Value

This example calls an internal business function that has no return value.

This portion is an example of b550001.h:

/* normal business function header pieces */
...
/* The internal business function prototype must be in the header for other
modules to call it */
void i550001(int *a, int b);

This portion is an example of b550001.c:

/* normal business function code pieces */
#include <b550001.h>
JDEBFRTN(ID) JDEBFWINAPI TestBSFN(LPBHVRCOM  lpVhvrCom,
LPVOID   lpVoid,
LPDSB550001 lpDS)
{
...
}
void i550001(int *a, int b)
{
*a = *a + b;
return;
}

This portion is an example of b550002.c:

/* normal business function code pieces */
#include <b550002.h>
#include <b550001.h>

JDEBFRTN(ID) JDEBFWINAPI TestBSFN(LPBHVRCOM  lpBhvrCom,
LPVOID   lpVoid,
LPDSB550001 lpDS)
{
int total = 3;
int adder = 7;

CALLIBF(i550001(&total,adder));
}

5.1.2.2 Example: Calling an Internal Business Function with a Return Value

This example calls an internal business function that has a return value.

This portion is an example of b550001.h:

/* normal business function header pieces */
...
/* The internal business function prototype must be in the header for
other modules to call it */

int i550001(int a, int b);

This portion is an example of b550001.c:

/* normal business function code pieces */
#include <b550001.h>

JDEBFRTN(ID) JDEBFWINAPI TestBSFN(LPBHVRCOM   lpBhvrCom,
LPVOID      lpVoid,
LPDSB550001 lpDS)
{
...
}
int i550001(int a, int b)
{
a = a + b;
return;
}

This portion is an example of b550002.c:

/* normal business function code pieces */
#include <b550002.h>
#include <b550001.h>

JDEBFRTN(ID) JDEBFWINAPI TestBSFN(LPBHVRCOM   lpBhvrCom,
LPVOID      lpVoid,
LPDSB550001 lpDS)
{
int total  = 0;
int adder1 = 6;
int adder2 = 7;
CALLIBFRET(total,i550001(adder1,adder2));
}

5.2 Passing Pointers between Business Functions

Never pass pointers directly in or out of business functions. A pointer memory address should not be greater than 32 bits. If you pass a pointer address that exceeds 32 bits across the platform to a client that supports just 32 bits, the significant digit might be truncated and invalidate the address.

The correct way to share pointers between business functions is to store the address in an array. This array is located on the server platform specified in the Object Configuration Manager (OCM). The array allows up to 100 memory locations to be allocated and stored, and it is maintained by JD Edwards EnterpriseOne tools. The index to a position in the array is a long integer type or ID. Use the GENLNG data dictionary object in the business function data structure to pass this index in or out of the business function.

5.2.1 Storing an Address in an Array

Use jdeStoreDataPtr to store an allocated memory pointer in an array for later retrieval. The index to the position in the array is returned. This index should be passed out through the business function data structure (lpDS).

5.2.1.1 Example: Storing an Address in an Array

This example illustrates how to store an address in an array:

If (lpDS->cReturnF4301PtrFlag == _J('1'))
{
lpDS->idF4301RowPtr = jdeStoreDataPtr(hUser,(void *)lpdsF4301);
}

5.2.2 Retrieving an Address from an Array

Use jdeRetrieveDataPtr to retrieve an address outside the current business function. The index to the position in the array should be passed in through the business function data structure (lpDS). When you use jdeRetrieveDataPtr, the address remains in the array and can be retrieved again later.

5.2.2.1 Example: Retrieving an Address from an Array

This example retrieves an address from an array:

lpdsF43199 = (LPF43199) jdeRetrieveDataPtr
(hUser, lpDS->idF43199Pointer);

5.2.3 Removing an Address from an Array

Use jdeRemoveDataPtr to remove the address from the array cell and release the array cell. The index to the position in the array should be passed in through the business function data structure (lpDS). A corresponding call to jdeRemoveDataPtr must exist for every jdeStoreDataPtr. If you use jdeAlloc to allocate memory, use jdeFree to free the memory.

5.2.3.1 Example: Removing an Address from an Array

This example removes an address from an array:

if (lpDS->idGenericLong != (ID) 0)
{
lpGenericPtr = (void *)jdeRemoveDataPtr(hUser,lpDS->idGenericLong);
if (lpGenericPtr != (void *) NULL)
{
jdeFree((void *)lpGenericPtr);
lpDS->idGenericLong = (ID) 0;
lpGenericPtr = (void *) NULL;
}
}

5.3 Allocating and Releasing Memory

Use jdeAlloc to allocate memory. Because jdeAlloc affects performance, use it sparingly.

Use jdeFree to release memory within a business function. For every jdeAlloc, a jdeFree should exist to release the memory.

Note:
Use the business function FreePtrToDataStructure, B4000640, to release memory through event rule logic.

5.3.1 Example: Allocating and Releasing Memory within a Business Function

This example uses jdeAlloc to allocate memory, and then, in the function cleanup section, jdeFree to release memory:

statement
lpdsF4301 = (LPF4301)jdeAlloc( COMMON_POOL,sizeof(F4301),MEM_ZEROINIT ) ;
statement

/**************************************************************
* Function Clean Up Section
**************************************************************/
if (lpdsF4301 != (LPF4301) NULL)
{
jdeFree( lpdsF4301 );
}

5.4 Using hRequest and hUser

Some API calls require either anhUser or anhRequest variable, or both. To get the hUser, use JDBInitBhvr. To get the hRequest, use JDBOpenTable. Initialize hUser and hRequest to NULL in the variable declaration line. All hRequest and hUser declarations should have JDB_CloseTable( ) and JDB_FreeBhvr( ) in the function cleanup section.

5.5 Typecasting

Typecasting is also known as type conversion. Use typecasting when the function requires a certain type of value, when defining function parameters, and when allocating memory with jdeAlloc().

Note:
This standard is for all function calls as well as function prototypes.

5.6 Comparison Testing

Always use explicit tests for comparisons. Do not embed assignments in comparison tests. Assign a value or result to a variable and use the variable in the comparison test.

Always test floating point variables using <= or >=. Do not use == or != since some floating point numbers cannot be represented exactly.

5.6.1 Example: Comparison Test

This example shows how to create C code for comparison tests.

eJDEDBResult = JDB_InitBhvr ((void*)lpBhvrCom,
&hUser,
(JCHAR *) NULL,
JDEDB_COMMIT_AUTO);

/** Check for Valid hUser **/
if (eJDEDBResult == JDEDB_PASSED)
{
statement;
}

5.6.2 Example: Creating TRUE or FALSE Test Comparison that Uses Boolean Logic

This example is a TRUE or FALSE test comparison that uses Boolean logic:

/* IsStringBlank has a BOOL return type. It will always return either
* TRUE or FALSE */
if ( IsStringBlank( szString) )
{
statement;
}

5.7 Copying Strings with jdeStrcpy or jdeStrncpy

When copying strings of the same length, such as business unit, you may use the jdeStrcpy ANSI API. If the strings differ in length-as with a description-use the jdeStrncpy ANSI API with the number of characters you need returned, not counting the trailing NULL character.

/**********************************************************
* Variable Definitions
**********************************************************/
JCHAR      szToBusinessUnit(13);
JCHAR      szFromBusinessUnit(13);
JCHAR      szToDescription(31);
JCHAR      szFromDescription(41);
/**********************************************************
* Main Processing
**********************************************************/
jdeStrcpy((JCHAR *) szToBusinessUnit,
(const JCHAR *) szFromBusinessUnit );

jdeStrncpy((JCHAR *) szToDescription,
(const JCHAR *) szFromDescription,
DIM(szToDescription)-1 );

5.8 Using the Function Clean Up Area

Use the function clean up area to release any allocated memory, including hRequest and hUser.

5.8.1 Example: Using the Function Clean Up Area to Release Memory

This example shows how to release memory in the function clean up area:

lpdsF4301 = (LPF4301)jdeAlloc( COMMON_POOL,
sizeof(F4301),MEM_ZEROINIT ) ;
/****************************************************************
* Function Clean Up Section
****************************************************************/
if (lpdsF4301 != (LPF4301 ) NULL)
{
jdeFree( lpdsF4301 );
}

if (hRequestF4301 != (HREQUEST) NULL)
{
JDB_CloseTable( hRequestF4301 );
}

JDB_FreeBhvr( hUser );

return ( idReturnValue ) ;

5.9 Inserting Function Exit Points

Where possible, use a single exit point (return) from the function. The code is more structured when a business function has a single exit point. The use of a single exit point also enables the programmer to perform cleanup, such as freeing memory and terminating ODBC requests, immediately before the return. In more complex functions, this action might be difficult or unreasonable. Include the necessary cleanup logic, such as freeing memory and terminating ODBC requests, when programming an exit point in the middle of a function.

Use the return value of the function to control statement execution. Business functions can have one of two return values: ER_SUCCESS or ER_ERROR. By initializing the return value for the function to ER_SUCCESS, the return value can be used to determine the processing flow.

5.9.1 Example: Inserting an Exit Point in a Function

This example illustrates the use of a return value for the function to control statement execution:

ID         idReturn        = ER_SUCCESS;
/**************************************************************
* Main Processing
**************************************************************/
memset( (void *)(&dsInfo), 0x00, sizeof(DSX51013_INFO) );
idReturn = X51013_VerifyAndRetrieveInformation( lpBhvrCom,
lpVoid,
lpDS,
&dsInfo );
/** Check for Errors and Company or Job Level Projections **/
if ( (idReturn == ER_SUCCESS) &&
(lpDS->cJobCostProjections == _J('Y')) )
{
/** Process All Periods between the From and Thru Dates **/
while ( (!dsInfo.bProcessed) &&
(idReturn == ER_SUCCESS) )
{
/** Retrieve Calculation Information **/
if ((dsInfo.bRetrieveBalance) && (idReturn == ER_SUCCESS))
{
idReturn = X51013_RetrieveAccountBalances( lpBhvrCom,
lpVoid,
lpDS,
&dsInfo );
}
if (idReturn == ER_SUCCESS)
{
statement;
}
} /* End Processing */
}

/***************************************************************
* Function Clean Up
***************************************************************/
if ( (dsInfo.hUser) != (HUSER) NULL )
{
statement;
}

return idReturn;

5.10 Terminating a Function

Always return a value with the termination of a function.

6 Coding for Portability

This chapter contains the following topics:

- Section 6.1, "Portability Concepts"

- Section 6.2, "Portability Guidelines"

- Section 6.3, "Preventing Common Server Build Errors and Warnings"

6.1 Portability Concepts

Portability is the ability to run a program on more than one system platform without modifying it. JD Edwards EnterpriseOne is a portable environment. This chapter presents considerations and guidelines for porting objects between systems.

Standards that affect the development of relational database systems are determined by:

- ANSI (American National Standards Institute) standard

- X/OPEN (European body) standard

- ISO SQL standard

Ideally, industry standards enable users to work identically with different relational database systems. Each major vendor supports industry standards but also offers extensions to enhance the functionality of the SQL language. In addition, vendors constantly release upgrades and new versions of their products.

These extensions and upgrades affect portability. Due to the effect of software development on the industry, applications need a standard interface to databases-an interface that will not be affected by differences among database vendors. When vendors provide a new release, the effect on existing applications needs to be minimal. To solve portability issues, many organizations have moved to standard database interfaces, called open database connectivity (ODBC).

6.2 Portability Guidelines

Refer to these guidelines to develop business functions that comply with portability standards:

- Business functions must be ANSI-compatible for portability.
Since different computer platforms might present limitations, exceptions to this rule do exist. However, do not use a non-ANSI exception without approval from the Business Function Standards Committee.

- Do not create a program that depends on data alignment, because each system aligns data differently by allocating bytes or words.
For example: for a one-character field that is one byte. Some systems allocate only one byte for that field, while other systems allocate the entire word for the field.

- Keep in mind that vendor libraries and function calls are system-dependent and exclusive to that vendor.
This means that if the program is compiled using a different compiler, that particular function will fail.

- Use caution when using pointer arithmetic because it is system-dependent and is based on the data alignment.

- Do not assume that all systems will initialize a variable the same way.
Always explicitly initialize variables.

- Use caution when using an offset to explicitly retrieve a value within the data structure.
This guideline also relates to data alignment. Use offset to define cache index.

- Always typecast if your parameter does not match the function parameter.

Note:
JCHAR szArray[13] is not the same as (JCHAR *) in the function declaration. Therefore, typecast of (JCHAR *) is required for szArray for that particular function.

- Never typecast on the left-hand side of the assignment statement, as it can result in a loss of data.
For example, in the statement (short)nValue = (long),lValue will lose the value of the long integer if it is too large to fit into a short integer data type.

- Do not use C++ comments (C++ comments begin with two forward slashes).

6.3 Preventing Common Server Build Errors and Warnings

JD Edwards EnterpriseOne business functions must be ANSI-compatible for portability. Since different computer platforms and servers have their own limitations, our business functions must comply with all server standards. This topic presents guidelines for coding business functions that correctly build on different servers.

6.3.1 Comments within Comments

Never use comments that are included in other comments. Each "/*" should be followed by subsequent "*/". Refer to these examples.

6.3.1.1 Example: C Comments that Comply with the ANSI Standard

Use this C standard comment block:

/**********************************************************************
* Correct Method of C Comments             *
*********************************************************************/
/* SAR 1234567 Begin*/
/* Populate the lpDS->OrderedPlacedBy value from the userID only in
the ADD mode */
if ( lpDS->cHeaderActionCode == _J('1'))
{
if (IsStringBlank(lpDS->szOrderedPlacedBy))
.{
jdeStrcpy((JCHAR *)(lpDS->szOrderedPlacedBy),
(const JCHAR *)(lpDS->szUserID));
}/* End of defaulting in the user id into Order placed by
if the later was left blank */
}/* SAR 1234567 End */

6.3.1.2 Example: C Comments that Comply with the ANSI Standard

Use this C standard comment block:

/**********************************************************************
* Correct Method of C Comments             *
*********************************************************************/
/* SAR 1234567 Begin*/
/* Populate the lpDS->OrderedPlacedBy value from the userID only in
the ADD mode */
if ( lpDS->cHeaderActionCode == _J('1'))
{
if (IsStringBlank(lpDS->szOrderedPlacedBy))
.{
jdeStrcpy((JCHAR *)(lpDS->szOrderedPlacedBy),
(const JCHAR *)(lpDS->szUserID));
}/* End of defaulting in the user id into Order placed by
if the later was left blank */
}/* SAR 1234567 End */

6.3.1.3 Example: Comments within Comments Cause Problems on Different Servers

This example shows that comments within comments can cause problem on different servers:

/**********************************************************************
C Comments within Comments Causing Server Build Errors and Warnings
*********************************************************************/
/* SAR 1234567 Begin
/* Populate the lpDS->OrderedPlacedBy value from the userID only in
the ADD mode */
*/
if ( lpDS->cHeaderActionCode == _J('1'))
{
if (IsStringBlank(lpDS->szOrderedPlacedBy))
{
jdeStrcpy((JCHAR *)(lpDS->szOrderedPlacedBy),
(const JCHAR *)(lpDS->szUserID));
}/* End of defaulting in the user id into the Order placed by
/* if the later was left blank */
}/* SAR 1234567 End */

6.3.2 New Line Character at the End of a Business Function

Some servers need a new line character at the end of the source and header file in order to build correctly. It is a best practice to ensure that a new line character is added at the end of each business function. Press the Enter key at the end of the code to add a new line character.

6.3.3 Use of Null Character

Be careful when using NULL character '\0'. This character starts with a back slash. Using '/0' is an error that is not reported by the compiler.

6.3.3.1 Example: Use of NULL Character

This example shows an incorrect and a correct use of the NULL character:

/*************Initialize Data Structures***************************/
/*Error Code*/
/* '/0' is used assuming it to be a NULL character*/
/* memset((void *)(&dsVerifyActivityRulesStatusCodeParms),
(int)('/0'), sizeof(DSD4000260A));*/

/*Correct Use of NULL Character*/
memset((void *)(&dsVerifyActivityRulesStatusCodeParms),
(int)('\0'), sizeof(DSD4000260A));

6.3.4 Lowercase Letters in Include Statements

When an external business function or table is included in the header file, use lowercase letters in the include statement. Uppercase letters cause build errors.

6.3.4.1 Example: Use of Lowercase Letters in Include Statements

This example shows the incorrect and correct use of lowercase letters in the include statement:

/**********************************************************************
* External Business Function Header Inclusions
********************************************************************/
/*Incorrect method of including external business function header*/
/*Include Statement Causing Build Warnings on Various Servers*/
#include <B0000130.h>
/*Correct method of including external business function header*/
#include <b0000130.h>

6.3.5 Initialized Variables that are Not Referenced

Each variable that is declared and initialized under the Variables Declaration section in the business function must be used in the program. For example: if the variable idReturnValue is initialized, then it must be used somewhere in the program.

7 Understanding JD Edwards EnterpriseOne Defined Structures

This chapter contains the following topics:

- Section 7.1, "MATH_NUMERIC Data Type"

- Section 7.2, "JDEDATE Data Type"

Oracle's JD Edwards EnterpriseOne provides two data types that should concern you when you create business functions: MATH_NUMERIC and JDEDATE. Since these data types might change, use the Common Library APIs provided by JD Edwards EnterpriseOne to manipulate them. Do not access the members of these data types directly.

7.1 MATH_NUMERIC Data Type

The MATH_NUMERIC data type is commonly used to represent numeric values in JD Edwards EnterpriseOne software. This data type is defined as follows:

struct tag MATH_NUMERIC

{
ZCHAR String [MAXLEN_MATH_NUMERIC + 1];
BYTE  Sign;
ZCHAR EditCode;
short nDecimalPosition;
short nLength;
WORD  wFlags;
ZCHAR szCurrency [4];
Short nCurrencyDecimals;
short nPrecision;
};

typedef struct tag MATH_NUMERIC MATH_NUMERIC, FAR *LPMATH_NUMERIC;

This table shows math-numeric elements and their descriptions:

MATH_NUMERIC Element

Description

String

The digits without separators

Sign

A minus sign indicates the number is negative. Otherwise, the value is 0x00.

EditCode

The data dictionary edit code used to format the number for display

nDecimalPosition

The number of digits from the right to place the decimal

nLength

The number of digits in the String

wFlags

Processing flags

szCurrency

Currency code

nCurrencyDecimals

The number of currency decimals

nPrecision

The data dictionary size

When assigning MATH_NUMERIC variables, use the MathCopy API. MathCopy copies the information, including Currency, into the location of the pointer. This API prevents any lost data in the assignment.

Initialize local MATH_NUMERIC variables with the ZeroMathNumeric API. If a MATH_NUMERIC is not initialized, invalid information, especially currency information, might be in the data structure, which can result in unexpected results at runtime.

/*************************************************
* Variable Definitions
*************************************************/
MATH_NUMERIC   mnVariable  = {0};

/************************************************
* Main Processing
************************************************/
ZeroMathNumeric( &mnVariable );
MathCopy( &mnVariable,
&lpDS->mnVariable );

7.2 JDEDATE Data Type

The JDEDATE data type is commonly used to represent dates in JD Edwards EnterpriseOne. The data type is defined as follows:

struct tag JDEDATE
{
short nYear;
short nMonth;
short nDay;
};

typedef struct tag JDEDATE JDEDATE, FAR *LPJDEDATE;

JDEDATE Element

Description

nYear

The year

nMonth

The month

nDay

The day

7.2.1 Using Memcpy to Assign JDEDATE Variables

When assigning JDEDATE variables, use the memcpy function. The memcpy function copies the information into the location of the pointer. If you use a flat assignment, you might lose the scope of the local variable in the assignment, which could result in a lost data assignment.

/****************************************************
* Variable Definitions
****************************************************/
JDEDATE   jdToDate;
/****************************************************
* Main Processing
****************************************************/
memcpy((void*) &jdToDate,
(const void *) &lpDS->jdFromDate,
sizeof(JDEDATE) );

7.2.2 JDEDATECopy

You can use JDEDATECopy, as well as memcpy, to assign JDEDATE variables. The syntax is as follows:

#define JDEDATECopy(pDest, pSource)
memcpy(pDest, pSource, sizeof(JDEDATE))

8 Implementing Error Messages

This chapter contains the following topics:

- Section 8.1, "Understanding Error Messages"

- Section 8.2, "Inserting Parameters for Error Messages in lpDS"

- Section 8.3, "Initializing Behavior Errors"

- Section 8.4, "Using Text Substitution to Display Specific Error Messages"

- Section 8.5, "Mapping Data Structure Errors with jdeCallObject"

8.1 Understanding Error Messages

Messages provide an effective and usable method of communicating information to end-users. You can use simple messages or text substitution messages.

Text substitution messages provide specific information to the user. At runtime, the system replaces variables in the message with substitution values. Two types of text substitution messages exist:

- Error messages (glossary group E)

- Workflow messages (glossary group Y)

The return code from all JDB and JDE Cache APIs must be checked and an appropriate error message set, returned, or both to the calling function. The standard error messages for JDB and JDE Cache errors are shown in these tables.

The JDB errors are:

Error ID

Description

078D

Open Table Failed

078E

Close Table Failed

078F

Insert to Table Failed

078G

Delete from Table Failed

078H

Update to Table Failed

078I

Fetch from Table Failed

078J

Select from Table Failed

078K

Set Sequence of Table Failed

078S *

Initialization of Behavior Failed

* 078S does not use text substitution

The JDE Cache errors are:

Error ID

Description

078L

Initialization of Cache Failed

078M

Open Cursor Failed

078N

Fetch from Cache Failed

078O

Add to Cache Failed

078P

Update to Cache Failed

078Q

Delete from Cache Failed

078R

Terminate of Cache Failed

8.2 Inserting Parameters for Error Messages in lpDS

Include the parameters cSuppressErrorMessage and szErrorMessageID in lpDS for error message processing. The functionality for each is as follows:

- cSuppressErrorMessage (SUPPS)
Valid data is either 1 or 0. This parameter is required if jdeErrorSet(...) is used in the business function. When cSuppressErrorMessage is set to 1, do not set an error because jdeErrorSet will automatically display an error message.

- szErrorMessageID (DTAI)
This 4–character string contains the error message ID value that is passed back by the business function. If an error occurs in the business function, szErrorMessageID contains that error number ID.

Note:
You must initialize szErrorMessageID to 4 spaces at the beginning of the function. Failure to initialize can cause memory errors.

8.2.1 Example: Parameters in lpDS for an Error Message

This example includes the lpDS parameters, cSuppressErrorMessage, and szErrorMessageID:

if ((!IsStringBlank(lpDS->szErrorMessageID)) &&
(lpDS->cSuppressErrorMessage != _J('1')))
{
jdeStrcpy ((JCHAR*) (lpDS->szErrorMessageID),
(const JCHAR*) (_J("0653")));
jdeErrorSet (lpBhvrCom, lpVoid, (ID) IDERRcMethodofComputation_1,
lpDS->szErrorMessageID, (LPVOID) NULL);
idReturnValue = ER_ERROR;
}

/***********************************************************
* Function Clean Up
***********************************************************/
return idReturnValue;

8.3 Initializing Behavior Errors

Business functions that use the JD Edwards EnterpriseOne database API are required to call the Initialize Behavior function before calling any of the database functions. Set error 078S if the Initialize Behavior function does not complete successfully.

8.3.1 Example: Initialize Behavior Error

This example illustrates an initialize behavior error:

/***********************************************************************
* Initialize Behavior
***********************************************************************/
idJDBReturn = JDB_InitBhvr(lpBhvrCom,
&hUser,
(JCHAR *) NULL,
JDEDB_COMMIT_AUTO);
if (idJDBReturn != JDEDB_PASSED)
{
jdeStrcpy (lpDS->szErrorMessageID, _J("078S"));
if (lpDS->cSuppressErrorMessage != _J('1'))
{
jdeErrorSet(lpBhvrCom, lpVoid, (ID)0, _J(078S), (LPVOID) NULL);
}
return ER_ERROR;
}

8.4 Using Text Substitution to Display Specific Error Messages

You can use the JD Edwards EnterpriseOne text substitution APIs for returning error messages within a business function. Text substitution is a flexible method for displaying a specific error message.

Text substitution is accomplished through the data dictionary. To use text substitution, you first must set up a data dictionary item that defines text substitution for the specific error message. A selection of error messages for JDB and JDE Cache have already been created and are listed in this chapter.

Error messages for cache and tables are critical in a configurable network computing (CNC) architecture. C programmers must set the appropriate error message when working with tables or cache APIs.

JDB API errors should substitute the name of the file against which the API failed. JDE cache API errors should substitute the name of the cache for which the API failed.

When calling errors that use text substitution, you must:

- Load a data structure with the information you want to substitute in the error message.

- Call jdeErrorSet to set the error.

8.4.1 Example: Text Substitution in an Error Message

This example uses text substitution in JDB_OpenTable:

/**************************************************************
* Open the General Ledger Table F0911
*************************************************************/
eJDBReturn = JDB_OpenTable( hUser,
ID_F0911,
ID_F0911_DOC_TYPE__NUMBER___B,
idColF0911,
nNumColsF0911,
(JCHAR *)NULL,
&hRequestF0911);

if (eJDBReturn != JDEDB_PASSED)
{
memset((void *)(&dsDE0022), 0x00, sizeof(dsDE0022));
jdeStrncpy((JCHAR *)dsDE0022.szDescription,
(const JCHAR *)(_J("F0911")),
DIM(dsDE0022.szDescription)-1);
jdeErrorSet (lpBhvrCom, lpVoid,(ID)0, _J("078D"), &dsDE0022);
}

8.5 Mapping Data Structure Errors with jdeCallObject

Any Business Function calling an external Business Function must use jdeCallObject. When using jdeCallObject, be sure to match the Error IDs correctly.

You need to match the Ids from the original Business Function with the Error Ids of the Business Function in jdeCallObject. A data structure is used in the jdeCallObject to accomplish this task.

/*************************************************************
* Variable declarations
*************************************************************/
CALLMAP   cm_D0000026[2]  = {{IDERRmnDisplayExchgRate_62,
IDERRmnExchangeRate_2}};
ID        idReturnCode    = ER_SUCCESS;  /* Return Code */
/************************************************************
* Business Function structures
*********************************************************/
DSD0000026  dsD0000026    = {0};    /* Edit Tolerance */

idReturnCode = jdeCallObject(_J("EditExchanbeRateTolerance"),
NULL,
lpBhvrCom,
lpVoid,
(void *)&dsD0000026,
(CALLMAP *)&cm_D0000026,
ND0000026,
(JCHAR *)NULL,
(JCHAR *)NULL,
(int)0);

9 Understanding Data Dictionary Triggers

This chapter contains the following topic:

- Section 9.1, "Data Dictionary Triggers"

9.1 Data Dictionary Triggers

Data dictionary triggers are used to attach edit-and-display logic to data dictionary items. The application runtime engine executes the trigger associated with a data dictionary item at the time that the item is accessed in a form.

Custom data dictionary triggers are written in C or Named Event Rule (NER), and require a specific data structure in order to execute correctly. The custom trigger data structure is composed of three predefined members and one variable member. The predefined members are the same for every custom trigger. The variable member is different for each trigger, and it is created using the specific data element associated with the data dictionary item.

This table shows the order of the members in the data structure along with the alias and a description of each member.

Structure Member Name

Alias

Description

idBhvrErrorId

BHVRERRID

Used by the trigger function to return the error status (ER_ERROR or ER_SUCCESS) to the application.

szBehaviorEditString

BHVREDTST

Used by the application runtime engine to pass the value for the data dictionary field to the trigger function.

szDescription001

DL01

Used by the trigger function to return the description for the value to the application.

szHomeCompany, mnAddressNumber

HMCO, AN8

Used by the trigger function to set errors (CALLMAP field).

10 Understanding Unicode Compliance Standards

This chapter contains the following topics:

- Section 10.1, "Unicode Compliance Standards"

- Section 10.2, "Unicode String Functions"

- Section 10.3, "Unicode Memory Functions"

- Section 10.4, "Pointer Arithmetic"

- Section 10.5, "Offsets"

- Section 10.6, "MATH_NUMERIC APIs"

- Section 10.7, "Third-Party APIs"

- Section 10.8, "Flat-File APIs"

10.1 Unicode Compliance Standards

The Unicode Standard is the universal character-encoding scheme for written characters and text. It defines a consistent way of way of encoding multilingual text that enables the exchange of text data internationally and creates the foundation for global software.

Facts about Unicode:

- Unicode is a very large character set containing the characters of virtually every written language.

- Unicode uses two bytes per character.
Up to 64,000 characters can be supported using two bytes. Unicode also has a mechanism called "surrogates," which uses pairs of two bytes to describe an additional one million characters.

- 0x00 is a valid byte in a character.
For example, the character "A" is described as 0x00 0x41, which means that normal string functions, such as strlen() and strcpy, do not work with Unicode data.

Do not use the data type char. Instead, use JCHAR for Unicode characters and ZCHAR for non-Unicode characters. Use ZCHAR instead of char in a code that needs to interface with non-Unicode APIs.

Old Syntax No Longer Available

New Syntax Non-Unicode

New Syntax Unicode

Char

ZCHAR

JCHAR

char *, PSTR

ZCHAR*, PZSTR

JCHAR*, PJSTR

'A'

_Z('A')

_J('A')

"string"

_Z("string")

_J("string")

10.2 Unicode String Functions

Two versions of all string functions exist: one for Unicode and one for non-Unicode. Naming standards for Unicode and non-Unicode string functions are:

- jdeSxxxxxx() indicates a Unicode string function

- jdeZSxxxx() indicates a non-Unicode string function

Some of the replacement functions include:

Old String Functions

New String Functions Non-Unicode

New String Functions Unicode

strcpy()

jdeZStrcpy()

jdeStrcpy()

strlen()

jdeZStrlen()

jdeStrlen()

strstr()

jdeZStrstr()

jdeStrstr()

sprintf()

jdeZSprintf()

jdeSprintf()

strncpy()

jdeZStrncpy()

jdeStrncpy()

Note:
The function jdestrcpy() was in use before the migration to Unicode. The Unicode slimer changed existing jdestrcpy() to jdeStrncpyTerminate(). Going forward, developers need to use jdeStrncpyTerminate() where they previously used jdestrcpy().

Do not use traditional string functions, such as strcpy, strlen, and printf. All the jdeStrxxxxxx functions explicitly handle strings, so use character length instead of the sizeof() operator, which returns a byte count.

When using jdeStrncpy(), the third parameter is the number of characters, not the number of bytes.

The DIM() macro gives the number of characters of an array. Given "JCHAR a[10];", DIM(a) returns 10, while sizeof(a) returns 20. "strncpy (a, b, sizeof (a));" needs to become "jdeStrncpy (a, b, DIM (a));".

10.2.1 Example: Using Unicode String Functions

This example shows how to use Unicode string functions:

/**********************************************************************
In this example jdeStrncpy replaces strncpy. Also sizeof is
replaced by DIM.
*********************************************************************/
/* Set key to F38112 */

/*Unicode Compliant*/
jdeStrncpy(dsKey1F38112.dxdcto,
(const JCHAR *)(dsF4311ZDetail->pwdcto),
DIM(dsKey1F38112.dxdcto) - 1);

10.3 Unicode Memory Functions

The memset() function changes memory byte by byte. For example, memset (buf, ' ', sizeof (buf)); sets the 10 bytes pointed to by the first argument, buf, to the value 0x20, the space character. Since a Unicode character is 2 bytes, each character is set to 0x2020, which is the dagger character (†) in Unicode.

A new function, jdeMemset() sets memory character by character rather than byte by byte. This function takes a void pointer, a JCHAR, and the number of bytes to set. Use jdeMemset (buf, _J (' '), sizeof (buf)); to set the Unicode string buf so that each character is 0x0020. When using jdeMemset(), the third parameter, sizeof(buf), is the number of bytes, not characters.

Note:
You can use memset when filling a memory block with NULL. For all other characters, use jdeMemset. You also can use jdeMemset for a NULL character.

10.3.1 Example: Using jdeMemset when Setting Characters to Values other than NULL

This example shows how to use jdeMemset when setting characters to values other than NULL:

/**********************************************************************
In this example memset is replaced by jdeMemset. We need to change
memset to jdeMemset because we are setting each character of the
string to a value other than NULL. Also, because jdeMemset works in
bytes, we cannot just subtract 1 from sizeof(szSubsidiaryBlank) to
prevent the last character from being set to ' '. We must multiply
1 by sizeof(JCHAR).
*********************************************************************/

/*Unicode Compliant*/
jdeMemset((void *)(szSubsidiaryBlank), _J(' '),
(sizeof(szSubsidiaryBlank) - (1*sizeof(JCHAR))));

10.4 Pointer Arithmetic

When advancing a JCHAR pointer, it is important to advance the pointer by the correct number. In the example, the intent is to initialize each member of an array consisting of JCHAR strings to blank. Inside the "For" loop, the pointer is advanced to point to the next member of the array of JCHAR strings after assigning a value to one of the members of the array. This is achieved by adding the maximum length of the string to the pointer. Since pStringPtr has been defined as a pointer to a JCHAR, adding MAXSTRLENGTH to pStringPtr results in pStringPtr pointing to the next member of the array of strings.

#define MAXSTRLENGTH 10
JCHAR             *pStringPtr;
LPMATH_NUMERIC    pmnPointerToF3007;
for(i=(iDayOfTheWeek+iNumberOfDaysInMonth);i<CALENDARDAYS;i++)
{
FormatMathNumeric(pStringPtr, &pmnPointerToF3007[i]);
pStringPtr = pStringPtr + MAXSTRLENGTH;
}

These tables illustrate the effect of adding MAXSTRLENGTH to pStringPtr. The top row in both tables contains memory locations; the bottom rows contain the contents of those memory locations.

The arrow indicates the memory location that pStringPtr points to before MAXSTRLENGTH is added to pStringPtr.

Figure 10-1 Example 1 of Unicode Pointer Arithmetic

Figure 10-2 Example 2 of Unicode Pointer Arithmetic

The arrow indicates the memory location that pStringPtr points to after MAXSTRLENGTH is added to pStringPtr. Adding 10 to pStringPtr makes it move 20 bytes, as it has been declared of type JCHAR.

Figure 10-3 Example 3 of Pointer Arithmetic

If pStringPtr is advanced by the value MAXSTRLENGTH * sizeof(JCHAR), then pStringPtr advances twice as much as intended and results in memory corruption.

10.5 Offsets

When adding an offset to a pointer to derive the location of another variable or entity, it is important to determine the method in which the offset was initially created.

In this example, lpKeyStruct->CacheKey[n].nOffset is added to lpData to arrive at the location of a Cache Key segment. This offset was for the segment created using the ANSI C function offsetof, which returns the number of bytes. Therefore, to arrive at the location of Cache Key segment, cast the data structure pointer to type BYTE.

lpTemp1 = (BYTE *)lpData + lpKeyStruct->CacheKey[n].nOffset;
lpTemp2 = (BYTE *)lpKey  + lpKeyStruct->CacheKey[n].nOffset;

In a non-Unicode environment, lpData could have been cast to be of type CHAR * as character size is one Byte in a non-Unicode environment. In a Unicode environment, however, lpData has to be explicitly cast to be of type (JCHAR *) since size of a JCHAR is 2 bytes.

10.6 MATH_NUMERIC APIs

The string members of the MATH_NUMERIC data structure are in ZCHAR (non-Unicode) format. The JD Edwards EnterpriseOne Common Library API includes several functions that retrieve and manipulate these strings in both JCHAR (Unicode) and ZCHAR (non-Unicode) formats.

To retrieve the string value of a MATH_NUMERIC data type in JCHAR format, use the FormatMathNumeric API function. This example illustrates the use of this function:

/* Declare variables */
JCHAR      szJobNumber[MAXLEN_MATH_NUMERIC+1] = _J("\0");
/* Retrieve the string value of the job number */
FormatMathNumeric(szJobNumber, &lpDS->mnJobnumber);

To retrieve the string value of a MATH_NUMERIC data type in ZCHAR format, use the jdeMathGetRawString API function. This example illustrates the use of this function:

/* Declare variables */
ZCHAR      zzJobNumber[MAXLEN_MATH_NUMERIC+1] = _Z("\0");
/* Retrieve the string value of the job number */
zzJobNumber = jdeMathGetRawString(&lpDS->mnJobnumber);

Another commonly used MATH_NUMERIC API function is jdeMathSetCurrencyCode. This function is used to update the currency code member of a MATH_NUMERIC data structure. Two versions of this function exist: jdeMathCurrencyCode and jdeMathCurrencyCodeUNI. The jdeMathCurrencyCode function is used to update the currency code with a ZCHAR value, and jdeMathCurrencyCodeUNI is used to update the currency code with a JCHAR value. This example illustrates the use of these two functions:

/* Declare variables */
ZCHAR      zzCurrencyCode[4] = _Z("USD");
JCHAR      szCurrencyCode[4] = _J("USD");
/* Set the currency code using a ZCHAR value */
jdeMathSetCurrencyCode(&lpDs->mnAmount, (ZCHAR *) zzCurrencyCode);
/* Set the currency code using a JCHAR value /*
jdeMathSetCurrencyCodeUNI(&lpDS->mnAmount, (JCHAR *) szCurrencyCode);

10.7 Third-Party APIs

Some third-party program interfaces (APIs) do not support Unicode character strings. In these cases, you must convert character strings to non-Unicode format before calling the API, and convert them back to Unicode format for storage in JD Edwards EnterpriseOne. Use these guidelines when programming for a non-Unicode API:

- Declare a Unicode and a non-Unicode variable for each API string parameter.

- Convert the Unicode strings to non-Unicode strings before calling the API.

- Call the API passing the non-Unicode strings in the parameter list.

- Convert the returned non-Unicode strings to Unicode strings for storage in JD Edwards EnterpriseOne.

10.7.1 Example: Third-Party API

This example calls a third-party API named GetStateName that accepts a two-character state code and returns a 30-character state name:

/* Declare variables */
JCHAR  szStateCode[3] = _J("CO");  /* Unicode state code */
JCHAR  szStateName[31] = _J("\0");  /* Unicode state name */
ZCHAR  zzStateCode[3] = _Z("\0");  /* Non-Unicode state code */
ZCHAR  zzStateName[31] = _Z("\0");  /* Non-Unicode state name */
BOOL  bReturnStatus = FALSE;    /* API return flag */
/* Convert unicode strings to non-unicode strings */
jdeFromUnicode(zzStateCode, szStateCode, DIM(zzStateCode), NULL);
/* Call API */
bReturnStatus = GetStateName(zzStateCode, zzStateName);
/* Convert non-unicode strings to unicode strings for storage in
* JD Edwards EnterpriseOne */
jdeToUnicode(szStateName, zzStateName, DIM(szStateName), NULL);

10.8 Flat-File APIs

JD Edwards EnterpriseOne APIs such as jdeFprintf() convert data. This means that the default flat file I/O for character data is in Unicode. If the users of JD Edwards EnterpriseOne-generated flat files are not Unicode enabled, they will not be able to read the flat file correctly. Therefore, use an additional set of APIs.

An interactive application allows users to configure flat file encoding based on attributes such as application name, application version name, user name, and environment name. The API set includes these file I/O functions: fwrite/fread, fprintf/fscanf, fputs/fgets, and fputc/fgetc. The API converts the data using the code page specified in the configuration application. One additional parameter, lpBhvrCom, must be passed to the functions so that the conversion function can find the configuration for that application or version.

These new APIs only need to be called if a process outside of JD Edwards EnterpriseOne is writing or reading the flat file data. If the file is simply a work file or a debugging file and will be written and read by JD Edwards EnterpriseOne, use the non-converting APIs (for example, jdeFprintf()).

10.8.1 Example: Flat-File APIs

This example writes text to a flat file that would only be read by JD Edwards EnterpriseOne. Encoding in the file will be Unicode.

FILE *fp;
fp = jdeFopen(_J( c:/testBSFNZ.txt), _J(w+));
jdeFprintf(fp, _J("%s%d\n"), _J("Line "), 1);
jdeFclose(fp);

This example writes text to a flat file that would be read by third-party systems. Encoding in the file will be based on the encoding configured.

FILE *fp;
fp = jdeFopen(_J( c:/testBSFNZ.txt), _J(w+));
jdeFprintfConvert(lpBhvrCom, fp, _J("%s%d\n"), _J("Line "), 1);
jdeFclose(fp);

See Also:

- "Using Flat Files" in the JD Edwards EnterpriseOne Tools Interoperability Guide.

11 Understanding Standard Header and Source Files

This chapter contains the following topics:

- Section 11.1, "Standard Header"

- Section 11.2, "Standard Source"

11.1 Standard Header

Header files help the compiler properly create a business function. The C language contains 33 keywords. Everything else, such as printf and getchar, is a function. Functions are defined in header files that you include at the beginning of a business function. Without header files, the compiler does not recognize the functions and might return error messages.

This example shows the standard header for a business function source file:

/****************************************************************
*  Header File: BXXXXXXX.h
*  Description: Generic Business Function Header File
*    History:
*     Date    Programmer SAR# - Description
*     ---------- ---------- ----------------------------
*  Author 03/15/2006           - Created
*
* Copyright (c) Oracle, 2006
*
* This unpublished material is proprietary to Oracle.
* All rights reserved. The methods and
* techniques described herein are considered trade secrets
* and/or confidential. Reproduction or distribution, in whole
* or in part, is forbidden except by express written permission
* of Oracle.
****************************************************************/
#ifndef __BXXXXXXX_H
#define __BXXXXXXX_H
/***************************************************************
* Table Header Inclusions
***************************************************************/

/**************************************************************
* External Business Function Header Inclusions
***************************************************************/

/**************************************************************
* Global Definitions
**************************************************************/

/**************************************************************
* Structure Definitions
**************************************************************/

/***************************************************************
* DS Template Type Definitions
**************************************************************/

/***************************************************************
* Source Preprocessor Definitions
**************************************************************/
#if defined (JDEBFRTN)
#undef JDEBFRTN
#endif

#if defined (WIN32)
#if defined (WIN32)
#define JDEBFRTN(r) __declspec(dllexport) r
#else
#define JDEBFRTN(r) __declspec(dllimport) r
#endif
#else
#define JDEBFRTN(r) r
#endif
/**************************************************************
* Business Function Prototypes
***************************************************************/
JDEBFRTN (ID) JDEBFWINAPI GenericBusinessFunction
(LPBHVRCOM     lpBhvrCom,
LPVOID        lpVoid,
LPDSDXXXXXXXX lpDS);

/**************************************************************
* Internal Function Prototypes
**************************************************************/
#endif  /* ___BXXXXXXX_H */

11.1.1 Business Function Name and Description

Use the Business Function Name and Description section to define the name of the business function, describe the business function, and maintain the modification log.

11.1.2 Copyright Notice

The Copyright section contains the Oracle copyright notice and must be included in each source file. Do not change this section.

11.1.3 Header Definition for a Business Function

The Header Definition section for a Business Function contains the "#define" of the business function. It is generated by the tool. Do not change this section.

11.1.4 Table Header Inclusions

The Table Header Inclusions section contains the include statements for the table headers associated with tables directly accessed by the business function.

See Lowercase Letters in Include Statements.

11.1.5 External Business Function Header Inclusions

The External Business Function Header Inclusions section contains the include statements for the business function headers associated with externally defined business functions that are directly accessed by the business function.

See Lowercase Letters in Include Statements.

11.1.6 Global Definitions

Use the Global Definitions section to define global constants used by the business function. Enter names in uppercase, separated by an underscore.

See Using Define Statements.

11.1.7 Structure Definitions

Define structures used by the business function in the Structure Definitions section. Structure names should be prefixed by the Source File Name to prevent conflicts with structures of the same name in other business functions.

See Understanding Naming ConventionsUsing Typedef Statements.

11.1.8 DS Template Type Definitions

The DS Template Type Definitions section defines the business functions contained in the source that correspond to the header. You generate the structure from the business function or data structure design window in Object Management Workbench. After you generate the structure, copy and paste it into this section.

11.1.9 Source Preprocessing Definitions

The Source Preprocessing Definitions section defines the entry point of the business function and includes the opening bracket required by C functions. Do not change this section.

11.1.10 Business Function Prototypes

Use the Business Function Prototypes section to prototype the functions defined in the source file.

See Creating Function Prototypes.

11.1.11 Internal Function Prototypes

The Internal Function Prototypes section contains a description and parameters of the function.

See Understanding Naming ConventionsCreating Function Prototypes.

11.2 Standard Source

The source file contains instructions for the business function. These sections describe the sections of a standard source file.

A template generated for a standard source file when you create a JD Edwards EnterpriseOne business function appears in the following pages:

#include <jde.h>
#define bxxxxxxx_c
/***************************************************************
*  Source File: bxxxxxxx
*
*  Description: Generic Business Function Source File
*
*    History:
*     Date    Programmer SAR# - Description
*    -------------------------------------------------------
*  Author 06/06/2005           - Created
*
* Copyright (c) Oracle, 2005
*
* This unpublished material is proprietary to Oracle.
* All rights reserved. The methods and techniques described
* herein are considered trade secrets and/or confidential.
* Reproduction or distribution, in whole or in part, is
* forbidden except by express written permission of
* Oracle.
**************************************************************/
/**************************************************************
* Notes:
*
**************************************************************/

#include <bxxxxxxx.h>
/*************************************************************
* Global Definitions

**************************************************************/

/*************************************************************
* Business Function: GenericBusinessFunction
*
*   Description: Generic Business Function
*
*   Parameters:
*   LPBHVRCOM  lpBhvrCom Business Function Communications
*   LPVOID    lpVoid  Void Parameter - DO NOT USE!
*   LPDSDXXXXXXX lpDS   Parameter Data Structure Pointer
*
*************************************************************/
JDEBFRTN (ID) JDEBFWINAPI GenericBusinessFunction
(LPBHVRCOM     lpBhvrCom,
LPVOID        lpVoid,
LPDSDXXXXXXXX lpDS)
{
/***********************************************************
* Variable declarations
***********************************************************/

/***********************************************************
* Declare structures
***********************************************************/

/***********************************************************
* Declare pointers
***********************************************************/

/***********************************************************
* Check for NULL pointers
***********************************************************/
if ((lpBhvrCom == (LPBHVRCOM) NULL) ||
(lPVoid  == (LPVOID)  NULL) ||
(lpDS   == (LPDSDXXXXXXXX) NULL))
{
jdeErrorSet (lpBhvrCom, lpVoid, (ID) 0,
4363, (LPVOID) NULL);
return ER_ERROR;
}
/***********************************************************
* Set pointers
***********************************************************/

/***********************************************************
* Main Processing
***********************************************************/

/***********************************************************
* Function Clean Up
***********************************************************/

return (ER_SUCCESS);
}
/* Internal function comment block */
/**************************************************************
*  Function: Ixxxxxxx_a // Replace xxxxxxx with source file
*             // number
*             // and a with the function name
*   Notes:
*
*  Returns:
*
* Parameters:
************************************************************/

11.2.1 Business Function Name and Description

Use this section to maintain the name and description of the business function. Also use this section to maintain the modification log.

11.2.2 Copyright Notice

The Copyright section contains the Oracle copyright notice and must be included in each source file. Do not make any changes to this section.

11.2.3 Notes

Use the Notes section to include information for anyone who might review the code in the future. For example, describe any peculiarities associated with the business function or any special logic.

11.2.4 Global Definitions

Use the Global Definitions section to define global constants used by the business function.

See Initializing Variables.

11.2.5 Header File for Associated Business Function

In the Header File for Associated Business Function section, include the header file associated with the business function using #include. If you need to include additional header files in the source, place them here.

11.2.6 Business Function Header

The Business Function Header section contains a description of each of the parameters used by the business function. Do not make any changes to this section.

11.2.7 Variable Declarations

The Variable Declarations section defines all required function variables. For ease of use, define the variables sequentially by type.

See Understanding Naming ConventionsInitializing Variables.

11.2.8 Declare Structures

Define any structures that are required by the function in the Declare Structures section.

See Creating Function Prototypes.

11.2.9 Pointers

If any pointers are required by the function, define them in the Pointers section. Name the pointer so that it reflects the structure to which it is pointing. For example, lpDS1100 is pointing to the structure DS1100.

11.2.10 Check for NULL Pointers

The Check for NULL Pointers section checks for parameter pointers that are NULL. Do not change this section.

11.2.11 Set Pointers

Use the Set Pointers section if you did not initialize the variables when declaring them. You must assign values to all pointers that you define.

See Creating Function Prototypes.

11.2.12 Main Processing

Use the Main Processing section to write the code.

11.2.13 Function Clean Up

Use the Function Clean Up section to release any allocated memory.

See Using the Function Clean Up Area.

11.2.14 Internal Function Comment Block

The Internal Function Comment Block section contains a description and parameters of the function.

See Understanding Naming Conventions.

Glossary

Accessor Methods/Assessors

Java methods to “get” and “set” the elements of a value object or other source file.

activity rule

The criteria by which an object progresses from one given point to the next in a flow.

add mode

A condition of a form that enables users to input data.

Advanced Planning Agent (APAg)

A JD Edwards EnterpriseOne tool that can be used to extract, transform, and load enterprise data. APAg supports access to data sources in the form of rational databases, flat file format, and other data or message encoding, such as XML.

application server

Software that provides the business logic for an application program in a distributed environment. The servers can be Oracle Application Server (OAS) or WebSphere Application Server (WAS).

Auto Commit Transaction

A database connection through which all database operations are immediately written to the database.

batch processing

A process of transferring records from a third-party system to JD Edwards EnterpriseOne.

In JD Edwards EnterpriseOne Financial Management, batch processing enables you to transfer invoices and vouchers that are entered in a system other than JD Edwards EnterpriseOne to JD Edwards EnterpriseOne Accounts Receivable and JD Edwards EnterpriseOne Accounts Payable, respectively. In addition, you can transfer address book information, including customer and supplier records, to JD Edwards EnterpriseOne.

batch server

A server that is designated for running batch processing requests. A batch server typically does not contain a database nor does it run interactive applications.

batch-of-one

A transaction method that enables a client application to perform work on a client workstation, then submit the work all at once to a server application for further processing. As a batch process is running on the server, the client application can continue performing other tasks.

best practices

Non-mandatory guidelines that help the developer make better design decisions.

BPEL

Abbreviation for Business Process Execution Language, a standard web services orchestration language, which enables you to assemble discrete services into an end-to-end process flow.

BPEL PM

Abbreviation for Business Process Execution Language Process Manager, a comprehensive infrastructure for creating, deploying, and managing BPEL business processes.

Build Configuration File

Configurable settings in a text file that are used by a build program to generate ANT scripts. ANT is a software tool used for automating build processes. These scripts build published business services.

build engineer

An actor that is responsible for building, mastering, and packaging artifacts. Some build engineers are responsible for building application artifacts, and some are responsible for building foundation artifacts.

Build Program

A WIN32 executable that reads build configuration files and generates an ANT script for building published business services.

business analyst

An actor that determines if and why an EnterpriseOne business service needs to be developed.

business function

A named set of user-created, reusable business rules and logs that can be called through event rules. Business functions can run a transaction or a subset of a transaction (check inventory, issue work orders, and so on). Business functions also contain the application programming interfaces (APIs) that enable them to be called from a form, a database trigger, or a non-JD Edwards EnterpriseOne application. Business functions can be combined with other business functions, forms, event rules, and other components to make up an application. Business functions can be created through event rules or third-generation languages, such as C. Examples of business functions include Credit Check and Item Availability.

business function event rule

See named event rule (NER).

business service

EnterpriseOne business logic written in Java. A business service is a collection of one or more artifacts. Unless specified otherwise, a business service implies both a published business service and business service.

business service artifacts

Source files, descriptors, and so on that are managed for business service development and are needed for the business service build process.

business service class method

A method that accesses resources provided by the business service framework.

business service configuration files

Configuration files include, but are not limited to, interop.ini, JDBj.ini, and jdelog.properties.

business service cross reference

A key and value data pair used during orchestration. Collectively refers to both the code and the key cross reference in the WSG/XPI based system.

business service cross-reference utilities

Utility services installed in a BPEL/ESB environment that are used to access JD Edwards EnterpriseOne orchestration cross-reference data.

business service development environment

A framework needed by an integration developer to develop and manage business services.

business services development tool

Otherwise known as JDeveloper.

business service EnterpriseOne object

A collection of artifacts managed by EnterpriseOne LCM tools. Named and represented within EnterpriseOne LCM similarly to other EnterpriseOne objects like tables, views, forms, and so on.

business service framework

Parts of the business service foundation that are specifically for supporting business service development.

business service payload

An object that is passed between an enterprise server and a business services server. The business service payload contains the input to the business service when passed to the business services server. The business service payload contains the results from the business service when passed to the Enterprise Server. In the case of notifications, the return business service payload contains the acknowledgement.

business service property

Key value data pairs used to control the behavior or functionality of business services.

Business Service Property Admin Tool

An EnterpriseOne application for developers and administrators to manage business service property records.

business service property business service group

A classification for business service property at the business service level. This is generally a business service name. A business service level contains one or more business service property groups. Each business service property group may contain zero or more business service property records.

business service property key

A unique name that identifies the business service property globally in the system.

business service property utilities

A utility API used in business service development to access EnterpriseOne business service property data.

business service property value

A value for a business service property.

business service repository

A source management system, for example ClearCase, where business service artifacts and build files are stored. Or, a physical directory in network.

business services server

The physical machine where the business services are located. Business services are run on an application server instance.

business services source file or business service class

One type of business service artifact. A text file with the .java file type written to be compiled by a Java compiler.

business service value object template

The structural representation of a business service value object used in a C-business function.

Business Service Value Object Template Utility

A utility used to create a business service value object template from a business service value object.

business services server artifact

The object to be deployed to the business services server.

business view

A means for selecting specific columns from one or more JD Edwards EnterpriseOne application tables whose data is used in an application or report. A business view does not select specific rows, nor does it contain any actual data. It is strictly a view through which you can manipulate data.

central objects merge

A process that blends a customer's modifications to the objects in a current release with objects in a new release.

central server

A server that has been designated to contain the originally installed version of the software (central objects) for deployment to client computers. In a typical JD Edwards EnterpriseOne installation, the software is loaded on to one machine—the central server. Then, copies of the software are pushed out or downloaded to various workstations attached to it. That way, if the software is altered or corrupted through its use on workstations, an original set of objects (central objects) is always available on the central server.

charts

Tables of information in JD Edwards EnterpriseOne that appear on forms in the software.

check-in repository

A repository for developers to check in and check out business service artifacts. There are multiple check-in repositories. Each can be used for a different purpose (for example, development, production, testing, and so on).

checksum

A fixed-size datum computed from an arbitrary block of digital data for the purpose of detecting accidental errors that may have been introduced during its transmission or storage. JD Edwards EnterpriseOne uses the checksum to verify the integrity of packages that have been downloaded by recomputing the checksum of the downloaded package and comparing it with the checksum of the original package. The procedure that yields the checksum from the data is called a checksum function or checksum algorithm. JD Edwards EnterpriseOne uses the MD5 and STA-1 checksum algorithms.

connector

Component-based interoperability model that enables third-party applications and JD Edwards EnterpriseOne to share logic and data. The JD Edwards EnterpriseOne connector architecture includes Java and COM connectors.

Control Table Workbench

An application that, during the Installation Workbench processing, runs the batch applications for the planned merges that update the data dictionary, user-defined codes, menus, and user override tables.

control tables merge

A process that blends a customer's modifications to the control tables with the data that accompanies a new release.

correlation data

The data used to tie HTTP responses with requests that consist of business service name and method.

credentials

A valid set of JD Edwards EnterpriseOne username/password/environment/role, EnterpriseOne session, or EnterpriseOne token.

cross-reference utility services

Utility services installed in a BPEL/ESB environment that access EnterpriseOne cross-reference data.

database credentials

A valid database username/password.

database server

A server in a local area network that maintains a database and performs searches for client computers.

Data Source Workbench

An application that, during the Installation Workbench process, copies all data sources that are defined in the installation plan from the Data Source Master and Table and Data Source Sizing tables in the Planner data source to the system-release number data source. It also updates the Data Source Plan detail record to reflect completion.

deployment artifacts

Artifacts that are needed for the deployment process, such as servers, ports, and such.

deployment server

A server that is used to install, maintain, and distribute software to one or more enterprise servers and client workstations.

direct connect

A transaction method in which a client application communicates interactively and directly with a server application.

See also batch-of-one and store-and-forward.

Do Not Translate (DNT)

A type of data source that must exist on the iSeries because of BLOB restrictions.

embedded application server instance

An OC4J instance started by and running wholly within JDeveloper.

edit code

A code that indicates how a specific value for a report or a form should appear or be formatted. The default edit codes that pertain to reporting require particular attention because they account for a substantial amount of information.

edit mode

A condition of a form that enables users to change data.

edit rule

A method used for formatting and validating user entries against a predefined rule or set of rules.

Electronic Data Interchange (EDI)

An interoperability model that enables paperless computer-to-computer exchange of business transactions between JD Edwards EnterpriseOne and third-party systems. Companies that use EDI must have translator software to convert data from the EDI standard format to the formats of their computer systems.

embedded event rule

An event rule that is specific to a particular table or application. Examples include form-to-form calls, hiding a field based on a processing option value, and calling a business function. Contrast with the business function event rule.

Employee Work Center

A central location for sending and receiving all JD Edwards EnterpriseOne messages (system and user generated), regardless of the originating application or user. Each user has a mailbox that contains workflow and other messages, including Active Messages.

enterprise server

A server that contains the database and the logic for JD Edwards EnterpriseOne.

Enterprise Service Bus (ESB)

Middleware infrastructure products or technologies based on web services standards that enable a service-oriented architecture using an event-driven and XML-based messaging framework (the bus).

EnterpriseOne administrator

An actor responsible for the EnterpriseOne administration system.

EnterpriseOne credentials

A user ID, password, environment, and role used to validate a user of EnterpriseOne.

EnterpriseOne development client

Historically called “fat client,” a collection of installed EnterpriseOne components required to develop EnterpriseOne artifacts, including the Microsoft Windows client and design tools.

EnterpriseOne extension

A JDeveloper component (plug-in) specific to EnterpriseOne. A JDeveloper wizard

is a specific example of an extension.

EnterpriseOne object

A reusable piece of code that is used to build applications. Object types include tables, forms, business functions, data dictionary items, batch processes, business views, event rules, versions, data structures, and media objects.

EnterpriseOne process

A software process that enables JD Edwards EnterpriseOne clients and servers to handle processing requests and run transactions. A client runs one process, and servers can have multiple instances of a process. JD Edwards EnterpriseOne processes can also be dedicated to specific tasks (for example, workflow messages and data replication) to ensure that critical processes don't have to wait if the server is particularly busy.

EnterpriseOne resource

Any EnterpriseOne table, metadata, business function, dictionary information, or other information restricted to authorized users.

Environment Workbench

An application that, during the Installation Workbench process, copies the environment information and Object Configuration Manager tables for each environment from the Planner data source to the system-release number data source. It also updates the Environment Plan detail record to reflect completion.

escalation monitor

A batch process that monitors pending requests or activities and restarts or forwards them to the next step or user after they have been inactive for a specified amount of time.

event rule

A logic statement that instructs the system to perform one or more operations based on an activity that can occur in a specific application, such as entering a form or exiting a field.

explicit transaction

Transaction used by a business service developer to explicitly control the type (auto or manual) and the scope of transaction boundaries within a business service.

exposed method or value object

Published business service source files or parts of published business service source files that are part of the published interface. These are part of the contract with the customer.

fast path

A command prompt that enables the user to move quickly among menus and applications by using specific commands.

file server

A server that stores files to be accessed by other computers on the network. Unlike a disk server, which appears to the user as a remote disk drive, a file server is a sophisticated device that not only stores files, but also manages them and maintains order as network users request files and make changes to these files.

final mode

The report processing mode of a processing mode of a program that updates or creates data records.

foundation

A framework that must be accessible for execution of business services at runtime. This includes, but is not limited to, the Java Connector and JDBj.

FTP server

A server that responds to requests for files via file transfer protocol.

HTTP Adapter

A generic set of services that are used to do the basic HTTP operations, such as GET, POST, PUT, DELETE, TRACE, HEAD, and OPTIONS with the provided URL.

instantiate

A Java term meaning “to create.” When a class is instantiated, a new instance

is created.

integration developer

The user of the system who develops, runs, and debugs the EnterpriseOne business services. The integration developer uses the EnterpriseOne business services to develop these components.

integration point (IP)

The business logic in previous implementations of EnterpriseOne that exposes a document level interface. This type of logic used to be called XBPs. In EnterpriseOne 8.11, IPs are implemented in Web Services Gateway powered by webMethods.

integration server

A server that facilitates interaction between diverse operating systems and applications across internal and external networked computer systems.

integrity test

A process used to supplement a company's internal balancing procedures by locating and reporting balancing problems and data inconsistencies.

interface table

See Z table.

internal method or value object

Business service source files or parts of business service source files that are not part of the published interface. These could be private or protected methods. These could be value objects not used in published methods.

interoperability model

A method for third-party systems to connect to or access JD Edwards EnterpriseOne.

in-your-face error

In JD Edwards EnterpriseOne, a form-level property which, when enabled, causes the text of application errors to appear on the form.

jargon

An alternative data dictionary item description that JD Edwards EnterpriseOne appears based on the product code of the current object.

Java application server

A component-based server that resides in the middle-tier of a server-centric architecture. This server provides middleware services for security and state maintenance, along with data access and persistence.

JDBNET

A database driver that enables heterogeneous servers to access each other's data.

JDEBASE Database Middleware

A JD Edwards EnterpriseOne proprietary database middleware package that provides platform-independent APIs, along with client-to-server access.

JDECallObject

An API used by business functions to invoke other business functions.

jde.ini

A JD Edwards EnterpriseOne file (or member for iSeries) that provides the runtime settings required for JD Edwards EnterpriseOne initialization. Specific versions of the file or member must reside on every machine running JD Edwards EnterpriseOne. This includes workstations and servers.

JDEIPC

Communications programming tools used by server code to regulate access to the same data in multiprocess environments, communicate and coordinate between processes, and create new processes.

jde.log

The main diagnostic log file of JD Edwards EnterpriseOne. This file is always located in the root directory on the primary drive and contains status and error messages from the startup and operation of JD Edwards EnterpriseOne.

JDENET

A JD Edwards EnterpriseOne proprietary communications middleware package. This package is a peer-to-peer, message-based, socket-based, multiprocess communications middleware solution. It handles client-to-server and server-to-server communications for all JD Edwards EnterpriseOne supported platforms.

JDeveloper Project

An artifact that JDeveloper uses to categorize and compile source files.

JDeveloper Workspace

An artifact that JDeveloper uses to organize project files. It contains one or more project files.

JMS Queue

A Java Messaging service queue used for point-to-point messaging.

listener service

A listener that listens for XML messages over HTTP.

local repository

A developer's local development environment that is used to store business service artifacts.

Location Workbench

An application that, during the Installation Workbench process, copies all locations that are defined in the installation plan from the Location Master table in the Planner data source to the system data source.

logic server

A server in a distributed network that provides the business logic for an application program. In a typical configuration, pristine objects are replicated on to the logic server from the central server. The logic server, in conjunction with workstations, actually performs the processing required when JD Edwards EnterpriseOne software runs.

MailMerge Workbench

An application that merges Microsoft Word 6.0 (or higher) word-processing documents with JD Edwards EnterpriseOne records to automatically print business documents. You can use MailMerge Workbench to print documents, such as form letters about verification of employment.

Manual Commit transaction

A database connection where all database operations delay writing to the database until a call to commit is made.

master business function (MBF)

An interactive master file that serves as a central location for adding, changing, and updating information in a database. Master business functions pass information between data entry forms and the appropriate tables. These master functions provide a common set of functions that contain all of the necessary default and editing rules for related programs. MBFs contain logic that ensures the integrity of adding, updating, and deleting information from databases.

master table

See published table.

media storage object

Files that use one of the following naming conventions that are not organized into table format: Gxxx, xxxGT, or GTxxx.

message center

A central location for sending and receiving all JD Edwards EnterpriseOne messages (system and user generated), regardless of the originating application or user.

messaging adapter

An interoperability model that enables third-party systems to connect to JD Edwards EnterpriseOne to exchange information through the use of messaging queues.

messaging server

A server that handles messages that are sent for use by other programs using a messaging API. Messaging servers typically employ a middleware program to perform their functions.

Monitoring Application

An EnterpriseOne tool provided for an administrator to get statistical information for various EnterpriseOne servers, reset statistics, and set notifications.

named event rule (NER)

Encapsulated, reusable business logic created using event rules, rather that C programming. NERs are also called business function event rules. NERs can be reused in multiple places by multiple programs. This modularity lends itself to streamlining, reusability of code, and less work.

Object Configuration Manager (OCM)

In JD Edwards EnterpriseOne, the object request broker and control center for the runtime environment. OCM keeps track of the runtime locations for business functions, data, and batch applications. When one of these objects is called, OCM directs access to it using defaults and overrides for a given environment and user.

Object Librarian

A repository of all versions, applications, and business functions reusable in building applications. Object Librarian provides check-out and check-incapabilities for developers, and it controls the creation, modification, and use of JD Edwards EnterpriseOne objects. Object Librarian supports multiple environments (such as production and development) and enables objects to be easily moved from one environment to another.

Object Librarian merge

A process that blends any modifications to the Object Librarian in a previous release into the Object Librarian in a new release.

Open Data Access (ODA)

An interoperability model that enables you to use SQL statements to extract JD Edwards EnterpriseOne data for summarization and report generation.

Output Stream Access (OSA)

An interoperability model that enables you to set up an interface for JD Edwards EnterpriseOne to pass data to another software package, such as Microsoft Excel, for processing.

package

JD Edwards EnterpriseOne objects are installed to workstations in packages from the deployment server. A package can be compared to a bill of material or kit that indicates the necessary objects for that workstation and where on the deployment server the installation program can find them. It is point-in-time snapshot of the central objects on the deployment server.

package build

A software application that facilitates the deployment of software changes and new applications to existing users. Additionally, in JD Edwards EnterpriseOne, a package build can be a compiled version of the software. When you upgrade your version of the ERP software, for example, you are said to take a package build.

Consider the following context: “Also, do not transfer business functions into the production path code until you are ready to deploy, because a global build of business functions done during a package build will automatically include the new functions.” The process of creating a package build is often referred to, as it is in this example, simply as “a package build.”

package location

The directory structure location for the package and its set of replicated objects. This is usually \\deployment server\release\path_code\package\package name. The subdirectories under this path are where the replicated objects for the package are placed. This is also referred to as where the package is built or stored.

Package Workbench

An application that, during the Installation Workbench process, transfers the package information tables from the Planner data source to the system-release number data source. It also updates the Package Plan detail record to reflect completion.

Pathcode Directory

The specific portion of the file system on the EnterpriseOne development client where EnterpriseOne development artifacts are stored.

patterns

General repeatable solutions to a commonly occurring problem in software design. For business service development, the focus is on the object relationships and interactions. For orchestrations, the focus is on the integration patterns (for example, synchronous and asynchronous request/response, publish, notify, and receive/reply).

print server

The interface between a printer and a network that enables network clients to connect to the printer and send their print jobs to it. A print server can be a computer, separate hardware device, or even hardware that resides inside of the printer itself.

pristine environment

A JD Edwards EnterpriseOne environment used to test unaltered objects with JD Edwards EnterpriseOne demonstration data or for training classes. You must have this environment so that you can compare pristine objects that you modify.

processing option

A data structure that enables users to supply parameters that regulate the running of a batch program or report. For example, you can use processing options to specify default values for certain fields, to determine how information appears or is printed, to specify date ranges, to supply runtime values that regulate program execution, and so on.

production environment

A JD Edwards EnterpriseOne environment in which users operate EnterpriseOne software.

Production Published Business Services Web Service

Published business services web service deployed to a production application server.

program temporary fix (PTF)

A representation of changes to JD Edwards EnterpriseOne software that your organization receives on magnetic tapes or disks.

project

In JD Edwards EnterpriseOne, a virtual container for objects being developed in Object Management Workbench.

promotion path

The designated path for advancing objects or projects in a workflow. The following is the normal promotion cycle (path):

11>21>26>28>38>01

In this path, 11 equals new project pending review, 21 equals programming, 26 equals QA test/review, 28 equals QA test/review complete, 38 equals in production, 01 equals complete. During the normal project promotion cycle, developers check objects out of and into the development path code and then promote them to the prototype path code. The objects are then moved to the productions path code before declaring them complete.

proxy server

A server that acts as a barrier between a workstation and the internet so that the enterprise can ensure security, administrative control, and caching service.

published business service

EnterpriseOne service level logic and interface. A classification of a published business service indicating the intention to be exposed to external (non-EnterpriseOne) systems.

published business service identification information

Information about a published business service used to determine relevant authorization records. Published business services + method name, published business services, or *ALL.

published business service web service

Published business services components packaged as J2EE Web Service (namely, a J2EE EAR file that contains business service classes, business service foundation, configuration files, and web service artifacts).

published table

Also called a master table, this is the central copy to be replicated to other machines. Residing on the publisher machine, the F98DRPUB table identifies all of the published tables and their associated publishers in the enterprise.

publisher

The server that is responsible for the published table. The F98DRPUB table identifies all of the published tables and their associated publishers in the enterprise.

QBE

An abbreviation for query by example. In JD Edwards EnterpriseOne, the QBE line is the top line on a detail area that is used for filtering data.

real-time event

A message triggered from EnterpriseOne application logic that is intended for external systems to consume.

refresh

A function used to modify JD Edwards EnterpriseOne software, or subset of it, such as a table or business data, so that it functions at a new release or cumulative update level.

replication server

A server that is responsible for replicating central objects to client machines.

rules

Mandatory guidelines that are not enforced by tooling, but must be followed in order to accomplish the desired results and to meet specified standards.

secure by default

A security model that assumes that a user does not have permission to execute an object unless there is a specific record indicating such permissions.

Secure Socket Layer (SSL)

A security protocol that provides communication privacy. SSL enables client and server applications to communicate in a way that is designed to prevent eavesdropping, tampering, and message forgery.

selection

Found on JD Edwards EnterpriseOne menus, a selection represents functions that you can access from a menu. To make a selection, type the associated number in the Selection field and press Enter.

serialize

The process of converting an object or data into a format for storage or transmission across a network connection link with the ability to reconstruct the original data or objects when needed.

Server Workbench

An application that, during the Installation Workbench process, copies the server configuration files from the Planner data source to the system-release number data source. The application also updates the Server Plan detail record to reflect completion.

SOA

Abbreviation for Service Oriented Architecture.

softcoding

A coding technique that enables an administrator to manipulate site-specific variables that affect the execution of a given process.

source repository

A repository for HTTP adapter and listener service development environment artifacts.

Specification merge

A merge that comprises three merges: Object Librarian merge, Versions List merge, and Central Objects merge. The merges blend customer modifications with data that accompanies a new release.

specification

A complete description of a JD Edwards EnterpriseOne object. Each object has its own specification, or name, which is used to build applications.

Specification Table Merge Workbench

An application that, during the Installation Workbench process, runs the batch applications that update the specification tables.

SSL Certificate

A special message signed by a certificate authority that contains the name of a user and that user's public key in such a way that anyone can "verify" that the message was signed by no one other than the certification authority and thereby develop trust in the user's public key.

store-and-forward

The mode of processing that enables users who are disconnected from a server to enter transactions and then later connect to the server to upload those transactions.

subscriber table

Table F98DRSUB, which is stored on the publisher server with the F98DRPUB table and identifies all of the subscriber machines for each published table.

super class

An inheritance concept of the Java language where a class is an instance of something, but is also more specific. “Tree” might be the super class of “Oak” and “Elm,” for example.

table access management (TAM)

The JD Edwards EnterpriseOne component that handles the storage and retrieval of use-defined data. TAM stores information, such as data dictionary definitions; application and report specifications; event rules; table definitions; business function input parameters and library information; and data structure definitions for running applications, reports, and business functions.

Table Conversion Workbench

An interoperability model that enables the exchange of information between JD Edwards EnterpriseOne and third-party systems using non-JD Edwards EnterpriseOne tables.

table conversion

An interoperability model that enables the exchange of information between JD Edwards EnterpriseOne and third-party systems using non-JD Edwards EnterpriseOne tables.

table event rules

Logic that is attached to database triggers that runs whenever the action specified by the trigger occurs against the table. Although JD Edwards EnterpriseOne enables event rules to be attached to application events, this functionality is application specific. Table event rules provide embedded logic at the table level.

terminal server

A server that enables terminals, microcomputers, and other devices to connect to a network or host computer or to devices attached to that particular computer.

transaction processing (TP) monitor

A monitor that controls data transfer between local and remote terminals and the applications that originated them. TP monitors also protect data integrity in the distributed environment and may include programs that validate data and format terminal screens.

transaction processing method

A method related to the management of a manual commit transaction boundary (for example, start, commit, rollback, and cancel).

transaction set

An electronic business transaction (electronic data interchange standard document) made up of segments.

trigger

One of several events specific to data dictionary items. You can attach logic to a data dictionary item that the system processes automatically when the event occurs.

triggering event

A specific workflow event that requires special action or has defined consequences or resulting actions.

user identification information

User ID, role, or *public.

User Overrides merge

Adds new user override records into a customer's user override table.

value object

A specific type of source file that holds input or output data, much like a data structure passes data. Value objects can be exposed (used in a published business service) or internal, and input or output. They are comprised of simple and complex elements and accessories to those elements.

versioning a published business service

Adding additional functionality/interfaces to the published business services without modifying the existing functionality/interfaces.

Versions List merge

The Versions List merge preserves any non-XJDE and non-ZJDE version specifications for objects that are valid in the new release, as well as their processing options data.

visual assist

Forms that can be invoked from a control via a trigger to assist the user in determining what data belongs in the control.

vocabulary override

An alternate description for a data dictionary item that appears on a specific JD Edwards EnterpriseOne form or report.

web application server

A web server that enables web applications to exchange data with the back-end systems and databases used in eBusiness transactions.

web server

A server that sends information as requested by a browser, using the TCP/IP set of protocols. A web server can do more than just coordination of requests from browsers; it can do anything a normal server can do, such as house applications or data. Any computer can be turned into a web server by installing server software and connecting the machine to the internet.

Web Service Description Language (WSDL)

An XML format for describing network services.

Web Service Inspection Language (WSIL)

An XML format for assisting in the inspection of a site for available services and a set of rules for how inspection-related information should be made.

web service softcoding record

An XML document that contains values that are used to configure a web service proxy. This document identifies the endpoint and conditionally includes security information.

web service softcoding template

An XML document that provides the structure for a soft coded record.

Where clause

The portion of a database operation that specifies which records the database operation will affect.

Windows terminal server

A multiuser server that enables terminals and minimally configured computers to display Windows applications even if they are not capable of running Windows software themselves. All client processing is performed centrally at the Windows terminal server and only display, keystroke, and mouse commands are transmitted over the network to the client terminal device.

wizard

A type of JDeveloper extension used to walk the user through a series of steps.

workbench

A program that enables users to access a group of related programs from a single entry point. Typically, the programs that you access from a workbench are used to complete a large business process. For example, you use the JD Edwards EnterpriseOne Payroll Cycle Workbench (P07210) to access all of the programs that the system uses to process payroll, print payments, create payroll reports, create journal entries, and update payroll history. Examples of JD Edwards EnterpriseOne workbenches include Service Management Workbench (P90CD020), Line Scheduling Workbench (P3153), Planning Workbench (P13700), Auditor's Workbench (P09E115), and Payroll Cycle Workbench.

workflow

The automation of a business process, in whole or in part, during which documents, information, or tasks are passed from one participant to another for action, according to a set of procedural rules.

workgroup server

A server that usually contains subsets of data replicated from a master network server. A workgroup server does not perform application or batch processing.

XAPI events

A service that uses system calls to capture JD Edwards EnterpriseOne transactions as they occur and then calls third-party software, end users, and other JD Edwards EnterpriseOne systems that have requested notification when the specified transactions occur to return a response.

XML CallObject

An interoperability capability that enables you to call business functions.

XML Dispatch

An interoperability capability that provides a single point of entry for all XML documents coming into JD Edwards EnterpriseOne for responses.

XML List

An interoperability capability that enables you to request and receive JD Edwards EnterpriseOne database information in chunks.

XML Service

An interoperability capability that enables you to request events from one JD Edwards EnterpriseOne system and receive a response from another JD Edwards EnterpriseOne system.

XML Transaction

An interoperability capability that enables you to use a predefined transaction type to send information to or request information from JD Edwards EnterpriseOne. XML transaction uses interface table functionality.

XML Transaction Service (XTS)

Transforms an XML document that is not in the JD Edwards EnterpriseOne format into an XML document that can be processed by JD Edwards EnterpriseOne. XTS then transforms the response back to the request originator XML format.

Z event

A service that uses interface table functionality to capture JD Edwards EnterpriseOne transactions and provide notification to third-party software, end users, and other JD Edwards EnterpriseOne systems that have requested to be notified when certain transactions occur.

Z table

A working table where non-JD Edwards EnterpriseOne information can be stored and then processed into JD Edwards EnterpriseOne. Z tables also can be used to retrieve JD Edwards EnterpriseOne data. Z tables are also known as interface tables.

Z transaction

Third-party data that is properly formatted in interface tables for updating to the JD Edwards EnterpriseOne database.

Index
A  B  C  D  E  F  G  H  I  J  L  M  N  O  P  R  S  T  U  V

A

API

examples of, 10.7.1, 10.8.1

flat file, 10.8

MATHNUMERIC, 10.6

third party, 10.7

Unicode, 10.6, 10.7, 10.8

B

business function data structure, 2.4

business functions

external, 5.1.1

internal, 5.1.2

C

change logs, 3.2

character set, 10.1

comments

/*comment */ style, 3.3

aligning, 3.3

examples, 3.3.1

readability, 3.3

comparison tests, 5.6 compound statements

aligning, 3.5

braces, 3.5, 3.5

declaring variables, 3.5

defined, 3.5

example, 3.5.2, 3.5.3, 3.5.4

formatting, 3.5.1

logical expressions, 3.5

number allowed per line, 3.5

parenthesis, 3.5

readability, 3.5

creating

business function definition, 4.4.3

business function prototypes, 4.4.1

C++ comments, 6.3.4.1

internal function definition, 4.4.4

internal function prototypes, 4.4.2

D

data dictionary trigger, 9.1

data structures

business function, 2.4

declaring and initializing, 4.6

examples of, 4.6.1

data type

JDEDATE, 7.2

MATH_NUMERIC, 7.1

declaring and initializing

data structures, 4.6

define statements, 4.2

examples, 4.2.1, 4.2.2, 4.3.1, 4.4.1, 4.4.2, 4.4.3, 4.4.4, 4.5.1, 4.6.1, 4.7.3.1

flag variables, 4.7.1, 4.7.3

function prototypes, 4.4

input and output parameters, 4.7.2

overview, 4

standard variables, 4.7

typedef statements, 4.3

variables, 4.5

define statements

declaring and initializing, 4.2

examples, 4.2.1, 4.2.2

E

entry point

defining in main body, 11.1.9

source preprocessing definitions, 11.1.9

errors

data structure, 8.5

lpDS, 8.2

standard, 8.3

text substitution, 8.4

external business function

calling, 5.1.1

example, 5.1.1.1

F

fetch variables, 4.7.3, 4.7.3

flag variables, 4.7.1

function, 2.2

function blocks, 3.5

function calls

data types, 5.1

external, 5.1.1

internal, 5.1.2

jdeCallObject, 5.1

long parameter lists, 5.1

return value, 5.1

function clean up area

example, 5.8

releasing memory, 5.8

function exit points

examples, 5.9.1

number, 5.9

using, 5.9

function prototypes

declaring and initializing, 4.4

examples, 4.4.1, 4.4.2, 4.4.3, 4.4.4

placement, 4.4

variable names, 4.4

G

GENLNG

retrieving an address, 5.2.2

storing an address, 5.2.1.1

use, 5.2.1

H

header file

change log, 3.2

naming standard, 2.1

template, 11.1

Hungarian notation for variables, 2.3.1

I

indentation

example, 3.4.1

readability, 3.4

initializing overview, 4 input and output parameters, 4.7.2 input parameters, 4.7.2 internal business functions, calling, 5.1.2

J

JDB Errors, 8.1

JDE Cache Errors, 8.1

jdeapp.h, 4.3

jdeCallObject

calling business functions, 5.1.1, 5.1.2

mapping data structure errors, 8.5

JDEDATE, 7.2 jdeMemset, 10.3, 10.3.1

L

logical expressions, 3.5

M

MATH_NUMERIC

assigning variables, 7.1

using in variable declarations, 4.5

MATH_Numeric

data type, 7.1

MathCopy, 7.1 memcpy, 7.2.1 memory

allocating, 5.3

jdeAlloc, 5.3

releasing, 5.3.1, 5.8

memory function

example, 10.3.1

unicode, 10.3

memset

setting data structure to NULL, 4.6.1

using, 10.3

multiple logical expressions, 3.5.4

N

naming standard

business function data structures, 2.4

definedtypedef statements, 4.3

examples, 2.3.1

flag variables, 4.7.1

functions, 2.2

source and header files, 2.1

standard variables, 4.7

variables, 2.3

O

offsets, 10.5

P

parenthesis, 3.5

pointer

example, 10.4

Unicode, 10.4

R

readability

comments, 3.3

compound statements, 3.5

examples, 3.3.1, 3.4.1, 3.5.1, 3.5.2, 3.5.3, 3.5.4

indenting code, 3.4

overview, 3

source and header change logs, 3.2

removing an address, 5.2.3.1 retrieving an address, 5.2.2.1

S

source file

change log, 3.2

naming standard, 2.1

source preprocessor section, 11.1.9 source template, 11.2 standard variables

boolean flag, 4.7

declaring and initializing, 4.7

examples, 4.7.3.1

flag variables, 4.7

StartFormDynamic, 4.2.1 storing an address, 5.2.1.1 strcpy vs. strncpy, 5.7 string functions, 10.2, 10.2.1 strings, copying, 5.7 syntax, 10.1

T

template

standard header, 11.1

standard source, 11.2

typecasting

in prototypes, 5.5

use of, 5.5

typedef statements

declaring and initializing, 4.3

examples, 4.3.1

U

Unicode

API, 10.6, 10.7, 10.8

character set, 10.1

standards, 10.1

syntax, 10.1

user-defined data structure, 4.3.1 using braces

example, 3.5.2, 3.5.3

for ease in subsequent modifications, 3.5.3

to clarify flow, 3.5.2

using standard variables, 4.7.3.1 using StartFormDynamic, 4.2.1

V

variable, 2.3

variable declarations

description, 4.5

initial values, 4.5

initialization of, 4.5

memset data structure to NULL, 4.5

number per line, 4.5

placement in functions, 4.5

use of NULL pointers, 4.5

using of MATH_NUMERIC variables, 4.5

variable initialization

examples, 4.5.1

types, 4.5

variable names, 2.3.1 variables

declaring, 4.5

initializing, 4.5.1

Oracle Legal Notices

Copyright Notice

Copyright © 1994-2014, Oracle and/or its affiliates. All rights reserved.

Trademark Notice

Oracle and Java are registered trademarks of Oracle and/or its affiliates. Other names may be trademarks of their respective owners.

Intel and Intel Xeon are trademarks or registered trademarks of Intel Corporation. All SPARC trademarks are used under license and are trademarks or registered trademarks of SPARC International, Inc. AMD, Opteron, the AMD logo, and the AMD Opteron logo are trademarks or registered trademarks of Advanced Micro Devices. UNIX is a registered trademark of The Open Group.

License Restrictions Warranty/Consequential Damages Disclaimer

This software and related documentation are provided under a license agreement containing restrictions on use and disclosure and are protected by intellectual property laws. Except as expressly permitted in your license agreement or allowed by law, you may not use, copy, reproduce, translate, broadcast, modify, license, transmit, distribute, exhibit, perform, publish, or display any part, in any form, or by any means. Reverse engineering, disassembly, or decompilation of this software, unless required by law for interoperability, is prohibited.

Warranty Disclaimer

The information contained herein is subject to change without notice and is not warranted to be error-free. If you find any errors, please report them to us in writing.

Restricted Rights Notice

If this is software or related documentation that is delivered to the U.S. Government or anyone licensing it on behalf of the U.S. Government, the following notice is applicable:

U.S. GOVERNMENT END USERS: Oracle programs, including any operating system, integrated software, any programs installed on the hardware, and/or documentation, delivered to U.S. Government end users are "commercial computer software" pursuant to the applicable Federal Acquisition Regulation and agency-specific supplemental regulations. As such, use, duplication, disclosure, modification, and adaptation of the programs, including any operating system, integrated software, any programs installed on the hardware, and/or documentation, shall be subject to license terms and license restrictions applicable to the programs. No other rights are granted to the U.S. Government.

Hazardous Applications Notice

This software or hardware is developed for general use in a variety of information management applications. It is not developed or intended for use in any inherently dangerous applications, including applications that may create a risk of personal injury. If you use this software or hardware in dangerous applications, then you shall be responsible to take all appropriate fail-safe, backup, redundancy, and other measures to ensure its safe use. Oracle Corporation and its affiliates disclaim any liability for any damages caused by use of this software or hardware in dangerous applications.

Third-Party Content, Products, and Services Disclaimer

This software or hardware and documentation may provide access to or information on content, products, and services from third parties. Oracle Corporation and its affiliates are not responsible for and expressly disclaim all warranties of any kind with respect to third-party content, products, and services. Oracle Corporation and its affiliates will not be responsible for any loss, costs, or damages incurred due to your access to or use of third-party content, products, or services.

Alpha and Beta Draft Documentation Notice

If this document is in preproduction status:

This documentation is in preproduction status and is intended for demonstration and preliminary use only. It may not be specific to the hardware on which you are using the software. Oracle Corporation and its affiliates are not responsible for and expressly disclaim all warranties of any kind with respect to this documentation and will not be responsible for any loss, costs, or damages incurred due to the use of this documentation.