Monster Media 1994 #1/monster.zip/monster/CLIPPER/CLIPTIPS.ZIP/IERROR52.ZIP/IERROR.TXT

Text File | 1993-10-19 | 19KB | 587 lines

                           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 <condition>
      <statements>...
      BEGIN SEQUENCE
         <statements>...
         LOOP
      END <statements>...
   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]