Errors

Any error is considered fatal by the preprocessor program. This means it will abort immediately. The debug mode (see section Running GRG) can be used to provide a lot of additional information to track down the error, if it is not immediately obvious. The following is a list of all the errors with pointers to any relevant help in alphabetical order.

grg: bad equate name (probably unescaped equate esc)
Either an undefined equate name, or the equate escape character has been used inadvertently without escaping in a text body (the \# character sequence should be used in this case).

grg: couldn't fill dynamic dbf file, 'filename'
Covers a number of possible errors that stem from not being able to transfer a delimited text input file into a growing dBase3+ file structure (used internally to hold databases).

grg: couldn't open dbf file, 'filename'
The named file declared via a GRGDBFFILE predefined macro could not be opened as a dBase3+ file (either doesn't exist or incorrect permissions).

grg: couldn't open dynamic SQL dbf file, 'filename'
Always generated when a SQL Query declared via a DATABASE predefined macro failed for some reason (check the SQL statement is correct via another means, ensure the physical database PHYSDB is defined).

grg: couldn't open dynamic dbf file, 'filename'
The named file declared via a DATABASE predefined macro could not be opened as a delimited text file (either doesn't exist or incorrect permissions).

grg: couldn't open file, 'filename'
The given filename could not be opened for some reason. Is the path correct, filename correct, and filename readable?

grg: couldn't open include file, 'filename'
The specified include file couldn't be opened for some reason. Is the path correct, filename correct, and filename readable?

grg: couldn't stop dynamic dbf file, 'filename'
Covers a number of possible errors that stem from not being able to restructure a delimited text input file that has been loaded into a growing dBase3+ file structure (used internally to hold databases). Check pattern definitions.

grg: dfa.beg alloc failed
Low level out of memory error during DFA construction from pattern definitions.

grg: dfa.chr alloc failed
Low level out of memory error during DFA construction from pattern definitions.

grg: dfa.end alloc failed
Low level out of memory error during DFA construction from pattern definitions.

grg: dfa.end realloc failed
Low level out of memory error during DFA construction from pattern definitions.

grg: dfa.mid alloc failed
Low level out of memory error during DFA construction from pattern definitions.

grg: division by zero
An attempt was made to divide a number by zero in an equate expression.

grg: equate argument expected, 'string'
An invalid argument was given to an equate macro definition. See section Predefined Macros on predefined macros in general and section EQUATE on equate macros in particular.

grg: equate definition too long, 'string'
The equate definition after reversing (or if entered as reversed) is too long and must be shortened. Splitting up into more than one equate is usually the best way to do this.

grg: equate right operand expected, 'string'
Any situation during equate processing where the operator expected a right operand (generally a variable name) immediately following the operator.

grg: equate stack overflow
When returning from evaluation of an equate back to the text body, filter definition or pattern definition from which it was called has more than one value left on the stack.

grg: equate stack underflow
When returning from evaluation of an equate back to the text body, filter definition or pattern definition from which it was called has less than zero values left on the stack. Or when an operator requires an operand from the stack but the stack is empty.

grg: equate var defined differently, 'string'
Occurs when assigning a value to a system variable that does not match the data type the system variable was declared with. Does not occur for local variables since they just coerce the value to match their type (if possible).

grg: field argument expected, 'string'
A field argument was expected for either the SORTON or BANNER predefined macros. See section Predefined Macros on field arguments and section SORTON and section BANNER on these macros in particular.

grg: field name too long
A field name is limited to ten characters (dBase3+ compatible).

grg: field right operand expected
A field operator has been used but the field name does not immediately follow the operator (or has not been given).

grg: filter equate - number/string/date expected
The data type returned by a filter definition based on an equate expression is not one of these.

grg: group text body too big
The definition of the text body of a group exceeded the maximum text body size.

grg: illegal ARG character
A character not allowed during the processing of the ARGS mode was seen.

grg: illegal TXT character
A character not allowed during the processing of the STANDARD mode was seen.

grg: illegal character, 'char'
The preprocessor is very strict about characters that are not where they should be. Check that all predefined macros start at the beginning of a line and that they start with the double percent sequence. Check that comment starts at the beginning of a line with a double percent space sequence. Check that the arguments given to the predefined macros are correct (make sure that user macro definitions and equate definitions have been given a name and that string arguments start with a double character). Also check that there are not any spurious control characters in the file. See section GRG File Format for an overview of the structure, syntax, and semantics of GRG files.

grg: illegal character or operator in equate, 'string'
A character that is not valid in its current position in an equate definition has been identified.

grg: index overflow
Occurs when using the stroke operator and the index given to access a character of a string was greater than the length of the string.

grg: index underflow
Occurs when using the stroke operator and the index given to access a character of a string was less than zero.

grg: inputs left bracket expected
The inputs keyword requires brackets to immediately follow it (although they can have no content).

grg: inputs right bracket expected
The inputs keyword requires brackets to immediately follow it (although they can have no content).

grg: invalid operand type
The data type of the operand did not meet the requirements of the operation being applied at the time.

grg: left token without right in pattern
An error in a pattern definition, the token is enclosed within <...> bracket pairs, the closing one is missing.

grg: local variable stack overflow
The number of local variables on the stack (those of the current equate all equates back up the call chain to the first one) have overrun the general equate processing stack.

grg: macro argument expected, 'string'
Something other than a macro argument was used with either the DEFINE or the EQUATE predefined macros. See section section Predefined Macros on macro arguments and section DEFINE and section EQUATE on these particular macros.

grg: maximum TeX block exceeded
A text body definition has exceeded the maximum size given in section Hard Limits on the hard limits of the preprocessor. There is no way to work around this, other than to reduce the size of the text body. This can be done by converting parts of the text body into user defined macros, user text bodies and equates.

grg: mismatch in comment brackets
One comment bracket (either { } or /* */ pairs) opening or closing is missing.

grg: mismatch in index brackets
One indexing bracket ([ ] pairs) opening or closing is missing.

grg: mismatch in loop brackets
One looping bracket ([ ] pairs) opening or closing is missing.

grg: mismatch in loop/call brackets
One looping/call bracket (( ) pairs) opening or closing is missing.

grg: missing loop separator
The loop separator ";" or "do" is missing.

grg: no database defined
Any GRG must declare at least one database file using the %%DATABASE predefined macro.

grg: no such database
Occurs when accessing a database with the -> mechanism or the : mechanism on a roll/through loop and the named database has not been declared via the DATABASE predefined macro.

grg: numeric argument expected, 'string'
One of the PAGE01 or PAGENN predefined macros expected a numeric argument. See section Predefined Macros on numeric arguments and sections section PAGE01 and section PAGENN on these two macros.

grg: numeric operand expected
An operation required a numeric data type.

grg: numeric operands expected
An operation required two numeric data types.

grg: numeric or string operand expected
An operation required a numeric or string data type.

grg: operands types differ
An operation requires two operands of any type but they must be of the same type.

grg: out of place argument, 'string'
This should never happen. If it does don't panic, just call for help.

grg: pattern parse error
There was a syntax error in the pattern definitions.

grg: premature end of pattern after escape sequence
There was a syntax error in the pattern definitions.

grg: pushback buffer exceeded
The internal pushback buffer has overflowed. This is used to pushback and cause this resource to break. See section section Hard Limits on the hard limits of the preprocessor. Break down include files into separate files and reduce the size of user macros to work around this problem.

grg: record index out of range
The given index in the x[n] or x->y[n] syntax was less than 1 or greater than the total number of records in the associated database.

grg: record loop right operand expected
The record loop has been given a ":" syntax to identify a loop through a named database but the database name has not been given or is not immediately adjacent to the colon character.

grg: reg. exp. syntax error "%<FLD>=<RE>", 'string'
The syntax of a filter condition used with the FILTER predefined macro is wrong. The error message shows the correct syntax. See section section FILTER on the construction of filter conditions.

grg: stack overflow
The stack overflowed during equate processing as there were too many items on it (note that the stack size is reduced both by operations pushing values onto it and by local variables).

grg: stack underflow
A value was required from the stack by an operation during equate processing but the stack was empty.

grg: stack value out of range
Similar to a stack overflow except that the overflow occured during the creation of a local variable rather than an operation pusing a value onto the stack.

grg: string argument expected, 'string'
One of the INCLUDE, DATABASE, or FILTER predefined macros expected a string argument. See section Predefined Macros on string arguments and section INCLUDE, section DATABASE, and section FILTER on these three macros.

grg: text body too big
The text body maximum size has been exceeded by the definition given for one of the predefined macros (such as a header, footer, record, equate etc).

grg: too many arguments for texpage01, 'string'
This has a maximum of two numeric arguments.

grg: too many arguments for texpagenn, 'string'
This has a maximum of two numeric arguments.

grg: too many arguments for texpattern, 'string'
This has a maximum of 5 string arguments.

grg: too many banner args, 'string'
The maximum number of field arguments to the BANNER predefined macro has been exceeded. See section Hard Limits on the hard limits of the preprocessor and section BANNER on this particular macro.

grg: too many blocks, 'string'
The maximum number of user defined text blocks has been exceeded. See section Hard Limits on the hard limits of the preprocessor and section BLOCK on this particular macro.

grg: too many equate defs, 'string'
The maximum number of equate definitions given by using the EQUATE predefined macro has been exceeded. See section Hard Limits on the hard limits of the preprocessor and section EQUATE on this particular macro.

grg: too many equate vars
The maximum number of local variables for an equate expression has been exceeded.

grg: too many file args, 'string'
The maximum number of file arguments given with the DATABASE predefined macro has been exceeded. See section Hard Limits on the hard limits of the preprocessor and section DATABASE on this particular macro.

grg: too many filter args, 'string'
The maximum number of filters specified by using the FILTER predefined macro has been exceeded. See section Hard Limits on the hard limits of the preprocessor and section FILTER on this particular macro.

grg: too many group args, 'string'
Not implemented.

grg: too many local vars
The maximum number of equate local variables has been exceeded. The maximum size is determined by the local variable table not the equate stack size.

grg: too many macro defs, 'string'
The maximum number of user macro definitions given by using the DEFINE predefined macro has been exceeded. See section Hard Limits on the hard limits of the preprocessor and section DEFINE on this particular macro.

grg: too many sort args, 'string'
The maximum sort depth specified by using the SORTON predefined macro has been exceeded. See sections section Hard Limits on the hard limits of the preprocessor and section SORTON on this particular macro.

grg: too many unique pattern characters
The DFA limits a number of internal resources, this is one. Simplify the pattern definitions where possible.

grg: too many unique pattern modes
The DFA limits a number of internal resources, this is one. Simplify the pattern definitions where possible.

grg: undefined equate variable, 'string'
A system variable is being used before it has been declared (by writing a value to it).

grg: undefined local variable, 'string'
A local variable is being used before it has been declared (by writing a value to it).

grg: undefined macro or equate, 'string'
An undefined user macro or equate definition has been used in a text body or in an equate (not user macros). See section Predefined Macros on macro definitions and section DEFINE and section EQUATE on user macros and equate definitions respectively.

grg: unknown banner field, 'string'
An unknown database field name argument has been given to the BANNER predefined macro. See section Predefined Macros on field arguments and section BANNER on this particular macro.

grg: unknown character token, 'token'
A pattern definition has been given a character set token which is not one of the predefined ones and has not been defined by the user.

grg: unknown dfa mode
A jump has been made to a DFA mode which has not been defined (this may be a result of not correctly setting the initial value with DFAMODE).

grg: unknown equate, 'string'
An undefined equate definition has been used in a text body or in an equate. See section Predefined Macros on macro definitions and section EQUATE on equate definitions.

grg: unknown field name, 'string'
An unknown database field name has been used in a text body or in an equate. See section Predefined Macros on text bodies and section EQUATE on equate definitions.

grg: unknown field type, 'string'
A field type defined in a dBase3+ database file has not been recognised as The valid recognised types are C, N, D and L.

grg: unknown mode
This should never happen. If it does don't panic, just call for help.

grg: unknown predefined GRG macro, 'string'
A predefined macro name has not been recognised. All predefined macros start with the GRG or TEX sequence, followed by the rest of the name which must match one of the valid names. Same error as below.

grg: unknown predefined tex macro, 'string'
An invalid predefined macro has been used. Check for spelling mistakes. See section Predefined Macros for a list of predefined macros. Note that predefined macros are not case sensitive.

grg: unknown sort field, 'string'
An unknown database field name argument has been given to the SORTON predefined macro. See section Predefined Macros on field arguments and section SORTON on this particular macro.

grg: unknown token
An error in a pattern definition, the resulting token should be one of the valid start of record, end of record, start of field, end of field, error or discard token values.

grg: unseparated condition
A condition construct has been used in an equate expression which is missing the "else" clause (or the "endif" clause if no "else" clause is given). Note that reversed expressions always require an "else" clause (the colon character) whereas unreversed expressions do not.

grg: unterminated condition
A condition construct has been used in an equate expression which is missing the "endif" or ";" terminator. All conditions require this terminator.

grg: unterminated string, 'string'
A string has been given with a missing end quote.

Go to the first, previous, next, last section, table of contents.