CA-Clipper 5.2 Internal Error Listing 10/03/93 0: Error System Integrity Error The error system has encountered an unknown error. The probable cause is memory corruption. 1: Evaluation Stack Underflow A stack error has occurred after a Return. 2: Memory Error A memory error has occurred before a RUN. The system has attempted to free the R space to DOS and DOS reported an error. The likely cause is corruption in the DOS memory allocation system. 3: Memory Error A memory error has occurred after a RUN that prevents rebuilding of the buffer system. This occurs when the system tries to rebuild the R space and there is less than 16K available from DOS. 4: Memory Error A memory error has occurred corrupting an internal buffer system. This happens when an attempt is made to free an internal buffer and it is already free. 5: Memory Error A memory error has occurred corrupting the buffer and EMM system. This occurs when attempting to map an EMM memory block into conventional address space and the EMM driver reports an error. 6: Buffer Error This occurs when attempting to attach a buffer to a database and the database already has a buffer. The probable cause is memory corruption. 7: Buffer Error This occurs when attempting to detach a database buffer from a database and there is no buffer to detach. The most probable cause is memory corruption. 8: Buffer Error The system ran out of database and/or index buffer handles. 9: Buffer Error The system ran out of memory when attempting to allocate a database and/or index buffer. 10: Too Many Nested BEGIN SEQUENCE/END Blocks Too many nested BEGIN SEQUENCE/END blocks have been defined. The maximum is 16. Note: The usual reason this occurs is a LOOP statement within a BEGIN SEQUENCE/END structure like the following: DO WHILE ... BEGIN SEQUENCE ... LOOP END ... ENDDO 11: BEGIN SEQUENCE/END Integrity Error An underflow of BEGIN SEQUENCE stack has occurred. This only happens if there is a pending END without a BEGIN SEQUENCE. 12: Evaluation stack underflow after BEGIN SEQUENCE/END Occurs after a BREAK. 14: SORT Error The system ran out of memory during a SORT operation while attempting to allocate a database buffer. 15: SORT Error Memory corruption has occurred during a SORT operation. 16: Database Not Open This occurs at the end of a large block database operation (such as APPEND, JOIN, UPDATE, or TOTAL) and one of the database files used in the operation is no longer open. Solution: Check user-defined function used within the erroneous statement for any statements that close database files. 17: NTX File Corrupted This occurs when an index buffer is found to be corrupted when attempting to update an index page. 18: NTX File Corrupted This occurs when an index buffer is found to be corrupted when attempting to update an index page and the index is UNIQUE. 19: NTX File Corrupted This occurs when an index buffer is found to be corrupted when attempting to update an index page and the index is non-UNIQUE. 20: NDX File Key Type Error An evaluation of a key in an (.ndx) file does not result in a character or number. This can only occur if the key is a logical value. 21: NDX File Key Type Error A SEEK expression evaluates to a different data type than the index expression. 22: NTX File Key Type Error A SEEK expression in an (.ntx) file evaluates to a logical or the system runs out of memory when evaluating the key expression. 24: Write Error This error occurs when a Clipper application is unable to write a database file or index to disk. Action: Check to make sure that sufficient disk space and directory entries are available. Make sure that the file is not marked read-only. In a network environment, make sure the application has the necessary rights to write to the file. 92: SORT/INDEX ON Error The system is unable to create a temporary file during a SORT or INDEX operation. This can occur for one of the following reasons: 1) No disk space; 2) Disk is write-protected; 3) No more directory entries; or 4) The file already exists and is read-only. 332: String/Array memory overflow The maximum capacity of the Segment Virtual Object Store (SVOS) system has been exceeded. Because of the dynamic nature of SVOS, it is impossible to state exactly when this error will occur (see the Release Notes database in Norton Guides, "5.01 Notes" under "Runtime Memory Management"). In the worst case, this error will occur when slightly over a megabyte of strings and/or arrays are in use; the best case is in excess of 16 megabytes. Action: This problem can be resolved by reducing the size and/or number of strings and arrays that are active at any one time. Probably the most common cause of this error is the declaration of extremely large arrays (e.g., LOCAL aArray[500][300]). Note that every array element requires memory to store -- even if its value is NIL -- and that the number of array elements in an array is determined by multiplying the number of elements in every dimension and adding the sum of all dimensions except for the last. For example, a 500x300 array has (500x300) + 500, or 150,500, elements. Because every array element in Clipper requires 14 bytes, this amounts to 150,500 x 14, or 2,107,000 bytes -- well in excess of one megabyte and therefore potentially dangerous. Note: There is no benefit gained by reusing arrays. Clipper is much more efficient when strings and arrays are thrown away and rebuilt often rather than kept around unnecessarily for long durations. 415: Cannot open overlay file This error occurs when a Clipper application cannot find or cannot open an overlay file. Overlay files include executable (EXE) files (in the case of dynamic overlays), pre-linked library (PLL) files, and static overlay (OVL) files. Action: Probably the most common cause of this error is insufficient file handles available to the Clipper application. The first step in trying to solve this problem is to increase the number of file handles available to the application, refer to "File and Buffers" section in the Runtime Environment chapter of the Programming and Utilities book. If insufficient file handles is not the problem, it is possible that the Clipper application cannot find the file it is trying to open. Refer to "Specifying the Location of Executable Files" section in the Runtime Environment chapter of the Programming and Utilities book. 416: Read error on dynamic page file Problem is not related to file handles or network access rights (dynamic manager always opens page files SHARED and READONLY). Make sure there is no other copy of the EXE somewhere else, in case the overlay manager is somehow getting hold of another file with the same name). 520: Attempt to get value for an invalid field type. Action: This error may indicate a corrupted database file. Fix the database. 521: Replacement of field with invalid data type. Self-explanatory. 612: EVAL() given something other than codeblock. Self-explanatory. 650: Out of stack space Use /STACK in RTlink to increase stack space. 666: C Function Attempt to Free Invalid Pointer Indicates that a C function attempted to free an invalid pointer. 667: Eval stack crashed The evaluation stack (containing LOCAL variables, etc.) has crashed into a locked VM segment. Basically, the system has run out of memory as the VM system only locks segments near the evaluation stack when the memory is very old. 668: Runtime error handler error There is an error in the runtime error handler. It is calling itself until the stack overflows. 669: Cannot expand MEMVAR table System has tried to expand the MEMVAR table, and is unable to do so due to insufficient memory. 670: Memory initialization error An error has occurred during the initialization or re-initialization of the memory system. This error usually indicates an extremely low memory condition at startup, or that an application that was RUN from within Clipper allocated DOS memory without freeing it. Action: If the error occurred at startup, more conventional memory should be made available for the application. If it occurred immediately following the RUN command, the application that was run should be eliminated to see if this solves the problem. This problem may also occur with an improperly linked or corrupted application. 701: Unable to locate keyboard driver upon startup. Check to see if the latest PLL link script file was used to build the PLL, that the latest libraries are used, and no third-party libraries are linked. 715: Printer not ready. Self-explanatory. 773: Dynamic overlay system not linked in. This may indicate an invalid link line or a corrupted executable file. 999: Attempt to execute invalid code Clipper has attempted to execute something that it doesn't recognize as valid clipper code. This error can occur if an attempt is made to execute code compiled with a new version of Clipper under an older version, or because of a corrupted or invalid executable. Make sure that all code is compiled under the same version of Clipper, and is being linked with the correct version of the libraries. If a third-party linker is used, see if the error occurs when using RTlink for Clipper. If a corrupted executable is suspected, recompile all OBJ files and relink. 1020: Record not found This error indicates one of the following conditions: 1) Invalid record number data type specified in DBGOTO(); 2) Invalid field data type encountered when loading a field from disk to memory; or 3) Invalid field data type encountered when storing a field from memory to disk. (Note: This error is applicable to the DBFNTX replaceable database driver (RDD), and may not be applicable to other RDDs.) 1102: Requested RDD not linked A database driver was specified, but that driver is not linked into the application. 1210: Data and Index files out of sync Database (DBF) files and index (NTX) files are out of sync. This usually happens when the database is updated without the index being open. If the cause of the problem was that the database was updated through a utility external to the application, simply recreate the index (NTX) file and restart the application. If the database was not updated outside of the application, check the code for the application to ensure that all indexes are open when updates are being done. Correct the code, recreate the index (NTX) files, and restart the application. 1242: Data type mismatch on key replacement An attempt was made to replace a key field in the database with invalid data type. 2155: Read error on index heading page A read error occurred when reading the heading page of the index file, or the header did not contain the NTX signature, or the macro compiler returned a syntax error when attempting to compile the key expression. 4406: Temp file read error An error was received when reading from a temporary file. This error is most likely to occur when the disk where the temporary files are written is full. Free up the necessary space on the drive for the temporary file, or redirect the temporary file to a different drive via the TEMPPATH option of the Clipper environment variable. 4412: Indexing miscalculation This error occurs during indexing if there has been a miscalculation of how indexing should occur. This error may be a "magic number" type of error. It's possible that this error will disappear if more or less records are present in the database. 4414: Indexing miscalculation This error occurs during indexing if there has been a miscalculation of how indexing should occur. This error may be a "magic number" type of error. It's possible that this error will disappear if more or less records are present in the database. 4424: Temp file creation error Error creating temporary file for indexing or sorting. This error can be received for several reasons: insufficient file handles, an invalid TEMPPATH or insufficient network rights for the directory where temporary files are created. Note that temporary files are created in the current directory if no TEMPPATH is specified. Action: Correct the environment. If insufficient network rights is the problem, either give the user the necessary rights, or redirect the temporary file to a more appropriate directory. 5302: Conventional memory exhausted This is an "out of memory" message that indicates that the Clipper application no longer has sufficient conventional memory available to continue. Specifically, this error occurs when the virtual memory system attempts and fails to bring a VM segment into conventional memory that had been swapped out to disk or expanded memory. Action: Make more conventional memory available to the VM system. This can be done in several ways: Increase the amount of conventional memory available before running the application -- remove TSRs, make use of 386 memory manager, etc. Use a third-party linker that can dynamically overlay C and assembly-language code. C and ASM are not automatically overlaid by RTlink and therefore sit in conventional memory throughout the execution of the application. Ensure that any C or ASM code in use is making use of the virtual memory system if it is doing dynamic memory allocation. Any memory allocated using the Fixed Memory Allocator functions _xalloc() and _xgrab() reduces the amount of conventional memory available if it is not immediately freed. 5304: Conventional Memory Exhausted This is an "out of memory" message that indicates that the Clipper application no longer has sufficient conventional memory available to continue. Specifically, this error occurs when a function attempts to allocate conventional memory and fails. This error can be received as a result of the failure of _xgrab in Extend System functions. Action: See action for 5302. 5305: VM Swap Space Exhausted There is insufficient room in the VM swap area in real memory to load virtualized data. This only occurs in the undocumented internal function _vmTwo(). The CA-Clipper runtime issues calls to the _vmTwo function when it must obtain two de-referenced virtual memory handles concurrently. Typically, _vmTwo() is useful for string operations such as copy or comparison. 5306: Conventional Memory Exhausted This is an "out of memory" message that indicates that the Clipper application no longer has sufficient conventional memory available to continue. Specifically, this error occurs when the virtual memory system attempts and fails to bring a VM segment into conventional memory that has been swapped out to disk or expanded memory. Action: See action for 5302. 5311: VMM Unable to Create Swap File The virtual memory (VM) subsystem is unable to create a swap file on disk. This occurs for several reasons, including: 1) The target disk is full; 2) The target directory is full; 3) Insufficient file handles are available; 4) An invalid path is specified in the SWAPPATH parameter of the CLIPPER environment variable, or on the command line used to start the application; or 5) The user has insufficient rights on a network drive to create the file. 5312: VM Swap File Overallocated This is an "out of memory" message that indicates that the Clipper application no longer has sufficient virtual memory available to continue. Specifically, this error occurs when the virtual memory system needs to swap a virtual memory segment out of conventional memory, and it has used all expanded memory and disk space that has been made available to it. Action: Make more virtual memory available to the application. This can be done by making more expanded memory available by increasing the E setting of the CLIPPER environment variable, or by making more disk space available by increasing the SWAPK setting of the CLIPPER environment variable. This problem can also be resolved by reducing the size and/or number of strings and arrays that are active at any one time. Probably, the most common cause of this error is the declaration of extremely large arrays (e.g., LOCAL aArray[4096][4096]). Note that every array element requires memory to store (even if its value is NIL) and that the number of array elements in an array is determined by multiplying the number of elements in every dimension and adding the sum of all dimensions except for the last. For example, a 4096 by 4096 array has (4096x4096)+4096 or 16,781,312 elements. Because every array element in Clipper requires 14 bytes, this amounts to 16,781,312x14, or 234,938,368 bytes -- well in excess of the theoretical capacity of the virtual memory system. Note: There is no benefit gained by reusing arrays. Clipper is much more efficient when strings and arrays are thrown away and rebuilt often rather than kept around unnecessarily for long durations. 5313: VMM Writer Error on Swap File Write errors typically occur for one of the following reasons: 1) Disk full; 2) Bad sector encountered; or 3) The swap file was deleted by another process within a multitasking environment on a workstation in which the SHARE utility has not been loaded. 5320: VMM IAMBS Manager Error IAMBS manager is unable to provide more memory, or it encountered an error. 5333: Misuse of VM System This error occurs when there is a misuse of the virtual memory system by either an internal or external (third-party) subsystem. The following suggestions may eliminate the problem: Check to see if the user is assigning an incorrect data type to a IAMBS or GET instance variable. This is a known cause for this error. If the user is using any third-party libraries, see if the error still occurs without the library. If the user is using a third-party linker, see if the problem occurs with .RTlink. [End]