Building for Linux

[mingodad]

Also happen with clips-6.4.2 from sourceforge.

I've noticed that when building on Linux a preprocessor macro is defined -DLINUX but building on Ubuntu-18-04 with gcc-9.4 the resulting binary doesn't accept ^C to quit, but if I remove the -DLINUX then the resulting binary does accept ^C.

Also would be nice to have a command line help option, I've implemented a simple one as this:

------------------------------- core/commline.c -------------------------------
old mode 100755
new mode 100644
index 0804f8e..2e7e45b
@@ -191,7 +191,7 @@ void RerouteStdin(
    /* the -f argument, then return.        */
    /*======================================*/
 
-   if (argc < 3)
+   if (argc < 2)
      { return; }
 
    /*=====================================*/
@@ -206,7 +206,11 @@ void RerouteStdin(
 
    for (i = 1 ; i < argc ; i++)
      {
-      if (strcmp(argv[i],"-f") == 0) theSwitch = BATCH_SWITCH;
+      if (argc < 3 || strcmp(argv[i],"-h") == 0) {
+          printf("usage: %s [-h] | [(-f | -f2 | -l) file_name]\n", argv[0]);
+          exit(1);
+      }
+      else if (strcmp(argv[i],"-f") == 0) theSwitch = BATCH_SWITCH;
 #if ! RUN_TIME
       else if (strcmp(argv[i],"-f2") == 0) theSwitch = BATCH_STAR_SWITCH;
       else if (strcmp(argv[i],"-l") == 0) theSwitch = LOAD_SWITCH;

[mingodad]

Refering to the ^C not working I just saw using the debugger that when -DLINUX is defined the signal handler is not set, what's the reason for it ?

[mingodad]

Manually converting Appendix G: CLIPS BNF to an EBNF understood by https://github.com/GuntherRademacher/rr we can generate a nice navigable railroad diagram (see bellow with instructions at the top).

//
// EBNF to be viewd at
//    (IPV6) https://www.bottlecaps.de/rr/ui
//    (IPV4) https://rr.red-dove.com/ui
//
// Copy and paste this at one of the urls shown above in the 'Edit Grammar' tab
// then click the 'View Diagram' tab.
//

start_navigation ::= CLIPS-program

//Data Types
symbol           ::= "A valid symbol as specified in section 2.3.1"

string           ::= "A valid string as specified in section 2.3.1"

float            ::= "A valid float as specified in section 2.3.1"

integer          ::= "A valid integer as specified in section 2.3.1"

instance-name    ::= "A valid instance-name as specified in section 2.3.1"

number           ::= float | integer

lexeme           ::= symbol | string

constant         ::= symbol | string | integer |
                   float | instance-name

comment          ::= string

variable-symbol ::= "A symbol beginning with an alphabetic character"

function-name    ::= "Any symbol which corresponds to a system or user defined function, a deffunction name, or a defgeneric name"

file-name        ::= "A symbol or string which is a valid file name (including path information) for the operating system under which CLIPS is running"

slot-name        ::= "A valid deftemplate slot name"
/*
<...-name>         ::= "A <symbol> where the ellipsis indicate what the symbol represents. For example, <rule-name> is a symbol which represents the name of a rule."
*/
//Variables and Expressions
single-field-variable ::= "?"variable-symbol

multifield-variable       ::= "$?"variable-symbol

global-variable           ::= "?*"symbol*

variable                  ::= single-field-variable |
                          multifield-variable |
                          global-variable

function-call             ::= '(' function-name expression* ')'

expression                ::= constant | variable |
                          function-call

action                    ::= expression

/*
...-expression            ::= "An <expression> which returns the type indicated by the ellipsis. For example, <integer-expression> should return an integer."
*/

//Constructs
CLIPS-program ::= construct*

construct          ::= deffacts-construct |
                   deftemplate-construct |
                   defglobal-construct |
                   defrule-construct |
                   deffunction-construct |
                   defgeneric-construct |
                   defmethod-construct |
                   defclass-construct |
                   definstance-construct |
                   defmessage-handler-construct |
                   defmodule-construct

//Deffacts Construct
deffacts-construct ::= "(deffacts" deffacts-name comment?
                             RHS-pattern* ')'

//Deftemplate Construct
deftemplate-construct
                       ::= "(deftemplate" deftemplate-name
                                        comment?
                              slot-definition* ')'

slot-definition   ::= single-slot-definition |
                    multislot-definition

single-slot-definition
                         ::= "(slot" slot-name template-attribute* ')'

multislot-definition
                         ::= "(multislot" slot-name
                              template-attribute* ')'

template-attribute
                         ::= default-attribute |
                   constraint-attribute

default-attribute
                      ::= "(default" ("?DERIVE" | "?NONE" | expression*) ')' |
                          "(default-dynamic" expression* ')'

//Fact Specification
RHS-pattern            ::= ordered-RHS-pattern |
                         template-RHS-pattern

ordered-RHS-pattern    ::= '(' symbol RHS-field+ ')'

template-RHS-pattern   ::= '(' deftemplate-name RHS-slot* ')'

RHS-slot               ::= single-field-RHS-slot |
                         multifield-RHS-slot

single-field-RHS-slot ::= '(' slot-name RHS-field ')'

multifield-RHS-slot    ::= '(' slot-name RHS-field* ')'

RHS-field              ::= variable |
                         constant |
                         function-call

//Defrule Construct
defrule-construct      ::= "(defrule" rule-name comment?
                                      declaration?
                            conditional-element*
                                      "=>"
                            action* ')'

declaration            ::= "(declare" rule-property+ ')'

rule-property ::=         "(salience" integer-expression ')' |
                                  "(auto-focus" boolean-symbol ')'

boolean-symbol ::=        "TRUE" | "FALSE"

conditional-element    ::= pattern-CE |
                          assigned-pattern-CE |
                          not-CE | and-CE | or-CE |
                          logical-CE | test-CE |
                          exists-CE | forall-CE

pattern-CE                ::= ordered-pattern-CE |
                          template-pattern-CE |
                          object-pattern-CE

assigned-pattern-CE       ::= single-field-variable "-" pattern-CE

not-CE                    ::= "(not" conditional-element ')'

and-CE                    ::= "(and" conditional-element+ ')'

or-CE                     ::= "(or" conditional-element+ ')'

logical-CE                ::= "(logical" conditional-element+ ')'

test-CE                   ::= "(test" function-call ')'

exists-CE                 ::= "(exists" conditional-element+ ')'

forall-CE                 ::= "(forall" conditional-element
                                  conditional-element+ ')'

ordered-pattern-CE        ::= '(' symbol constraint* ')'

template-pattern-CE       ::= '(' deftemplate-name LHS-slot* ')'

object-pattern-CE         ::= "(object" attribute-constraint* ')'

attribute-constraint      ::= "(is-a" constraint ')' |
                                    "(name" constraint ')' |
                                    '(' slot-name constraint* ')'

LHS-slot                  ::= single-field-LHS-slot |
                          multifield-LHS-slot

single-field-LHS-slot ::= '(' slot-name constraint ')'

multifield-LHS-slot       ::= '(' slot-name constraint* ')'

constraint                ::= '?' | "$?" | connected-constraint

connected-constraint
                 ::= single-constraint |
           single-constraint '&' connected-constraint |
           single-constraint '|' connected-constraint

single-constraint         ::= term | '~'term

term                      ::= constant |
                          single-field-variable |
                        multifield-variable |
                                  ':' function-call |
                                  '=' function-call

//Defglobal Construct
defglobal-construct   ::= "(defglobal" defmodule-name?
                           global-assignment* ')'

global-assignment     ::= global-variable '=' expression

global-variable       ::= "?*" symbol*

//Deffunction Construct
deffunction-construct
                 ::= "(deffunction" name comment?
                        '(' regular-parameter* wildcard-parameter? ')'
              action* ')'

regular-parameter   ::= single-field-variable

wildcard-parameter ::= multifield-variable

//Defgeneric Construct
defgeneric-construct ::= "(defgeneric" name comment? ')'

//Defmethod Construct
defmethod-construct
            ::= "(defmethod" name index? comment?
                   '(' parameter-restriction*
                   wildcard-parameter-restriction? ')'
         action* ')'

parameter-restriction
                ::= single-field-variable |
                     '(' single-field-variable type* query? ')'

wildcard-parameter-restriction
                        ::= multifield-variable |
                            '(' multifield-variable type* query? ')'

type                ::= class-name

query               ::= global-variable | function-call

//Defclass Construct

defclass-construct ::= "(defclass" name comment?
                                  "(is-a" superclass-name+ ')'
                                   role?
                                   pattern-match-role?
                         slot*
                         handler-documentation* ')'

role    ::= "(role" ("concrete" | "abstract") ')'

pattern-match-role
            ::= "(pattern-match" ("reactive" | "non-reactive") ')'

slot    ::= "(slot" name facet* ')' |
                  "(single-slot" name facet* ')' |
                  "(multislot" name facet* ')'

facet ::=default-facet | storage-facet |
           access-facet | propagation-facet |
           source-facet | pattern-match-facet |
           visibility-facet | create-accessor-facet
           override-message-facet | constraint-attribute

default-facet ::=
               "(default" ("?DERIVE" | "?NONE" | expression*) ')' |
               "(default-dynamic" expression* ')'

storage-facet ::= "(storage" ("local" | "shared") ')'

access-facet
           ::= "(access" ("read-write" | "read-only" | "initialize-only") ')'

propagation-facet ::= "(propagation" ("inherit" | "no-inherit") ')'

source-facet ::= "(source" ("exclusive" | "composite") ')'

pattern-match-facet
           ::= "(pattern-match" ("reactive" | "non-reactive") ')'

visibility-facet ::= "(visibility" ("private" | "public") ')'

create-accessor-facet
         ::= "(create-accessor" ("?NONE" | "read" | "write" | "read-write") ')'

override-message-facet
         ::= "(override-message" ("?DEFAULT" | message-name) ')'

handler-documentation
           ::= "(message-handler" name handler-type? ')'

handler-type ::= "primary" | "around" | "before" | "after"

//Defmessage-handler Construct
defmessage-handler-construct
                 ::= "(defmessage-handler" class-name
              message-name handler-type? comment?
                            '(' parameter* wildcard-parameter? ')'
                  action* ')'

handler-type         ::= "around" | "before" | "primary" | "after"

parameter            ::= single-field-variable

wildcard-parameter ::= multifield-variable

//Definstances Construct
definstances-construct
                      ::= "(definstances" definstances-name
                             "active"? comment?
                   instance-template* ')'

instance-template     ::= '(' instance-definition ')'

instance-definition ::= instance-name-expression? "of"
                         class-name-expression
                         slot-override*

slot-override        ::= '(' slot-name-expression expression* ')'

//Defmodule Construct
defmodule-construct ::= "(defmodule" module-name comment?
                         port-specification* ')'

port-specification    ::= "(export" port-item ')' |
                                  "(import" module-name port-item ')'

port-item             ::= "?ALL" |
                                  "?NONE" |
                        port-construct "?ALL" |
                        port-construct "?NONE" |
                        port-construct construct-name+

port-construct        ::= "deftemplate" | "defclass" |
                                  "defglobal" | "deffunction" |
                                  "defgeneric"

//Constraint Attributes
constraint-attribute
                            ::= type-attribute |
                      allowed-constant-attribute |
                      range-attribute |
                      cardinality-attribute

type-attribute        ::= "(type" type-specification ')'

type-specification    ::= allowed-type+ | "?VARIABLE"


allowed-type              ::= "SYMBOL" | "STRING" | "LEXEME" |
                                    "INTEGER" | "FLOAT" | "NUMBER" |
                                    "INSTANCE-NAME" | "INSTANCE-ADDRESS" |
                                    "INSTANCE" | "EXTERNAL-ADDRESS" |
                                    "FACT-ADDRESS"

allowed-constant-attribute
                     ::= "(allowed-symbols" symbol-list ')' |
                         "(allowed-strings" string-list ')' |
                         "(allowed-lexemes" lexeme-list ')' |
                         "(allowed-integers" integer-list ')' |
                         "(allowed-floats" float-list ')' |
                         "(allowed-numbers" number-list ')' |
                         "(allowed-instance-names" instance-list ')' |
                         "(allowed-classes" class-name-list ')' |
                         "(allowed-values" value-list ')'

symbol-list               ::= symbol+ | "?VARIABLE"

string-list               ::= string+ | "?VARIABLE"

lexeme-list               ::= lexeme+ | "?VARIABLE"

integer-list              ::= integer+ | "?VARIABLE"

float-list                ::= float+ | "?VARIABLE"

number-list               ::= number+ | "?VARIABLE"

instance-name-list        ::= instance-name+ | "?VARIABLE"

class-name-list           ::= class-name+ | "?VARIABLE"

value-list                ::= constant+ | "?VARIABLE"

range-attribute           ::= "(range" range-specification
                                 range-specification ')'

range-specification ::= number | "?VARIABLE"

cardinality-attribute
                      ::= "(cardinality" cardinality-specification
                             cardinality-specification ')'

cardinality-specification
                          ::= integer | "?VARIABLE"

[mingodad]

After trying to build a PEG parser for clips using the EBNF shown above and the documentation I found that it's lacking several elements.
Here is the EBNF from the attempted PEG grammar:

//
// EBNF to be viewd at
//    (IPV6) https://www.bottlecaps.de/rr/ui
//    (IPV4) https://rr.red-dove.com/ui
//
// Copy and paste this at one of the urls shown above in the 'Edit Grammar' tab
// then click the 'View Diagram' tab.
//

//From: https://www.clipsrules.net/

//Constructs
CLIPS_program ::= construct*

construct ::=
	deffacts_construct
	| deftemplate_construct
	| defglobal_construct
	| defrule_construct
	| deffunction_construct
	| defgeneric_construct
	| defmethod_construct
	| defclass_construct
	| definstances_construct
	| defmessage_handler_construct
	| defmodule_construct

//Deffacts Construct
deffacts_construct ::=
	'(' "deffacts" deffacts_name comment? RHS_pattern* ')'

//Deftemplate Construct
deftemplate_construct ::=
	'(' "deftemplate" deftemplate_name comment? slot_definition* ')'

slot_definition ::=
	single_slot_definition
	| multislot_definition

single_slot_definition ::=
	'(' "slot" slot_name template_attribute* ')'

multislot_definition ::=
	'(' "multislot" slot_name template_attribute* ')'

template_attribute ::=
	default_attribute
	| constraint_attribute

default_attribute ::=
	'(' "default" ("?DERIVE" |"?NONE" |expression*) ')'
	| '(' "default_dynamic" expression* ')'

//Fact Specification
RHS_pattern ::=
	ordered_RHS_pattern
	| template_RHS_pattern

ordered_RHS_pattern ::=
	'(' symbol RHS_field+ ')'

template_RHS_pattern ::=
	'(' deftemplate_name RHS_slot* ')'

RHS_slot ::=
	single_field_RHS_slot
	| multifield_RHS_slot

single_field_RHS_slot ::=
	'(' slot_name RHS_field ')'

multifield_RHS_slot ::=
	'(' slot_name RHS_field* ')'

RHS_field ::=
	variable
	| constant
	| function_call

//Defrule Construct
defrule_construct ::=
	'(' "defrule" rule_name comment? declaration? conditional_element* "=>" action* ')'

declaration ::=
	'(' "declare" rule_property+ ')'

rule_property ::=
	'(' "salience" integer_expression ')'
	| '(' "auto_focus" boolean_symbol ')'

boolean_symbol ::=
	"TRUE"
	| "FALSE"

conditional_element ::=
	pattern_CE
	| assigned_pattern_CE
	| not_CE
	| and_CE
	| or_CE
	| logical_CE
	| test_CE
	| exists_CE |forall_CE

pattern_CE ::=
	ordered_pattern_CE
	| template_pattern_CE
	| object_pattern_CE

assigned_pattern_CE ::=
	single_field_variable "-" pattern_CE

not_CE ::=
	'(' "not" conditional_element ')'

and_CE ::=
	'(' "and" conditional_element+ ')'

or_CE ::=
	'(' "or" conditional_element+ ')'

logical_CE ::=
	'(' "logical" conditional_element+ ')'

test_CE ::=
	'(' "test" function_call ')'

exists_CE ::=
	'(' "exists" conditional_element+ ')'

forall_CE ::=
	'(' "forall" conditional_element conditional_element+ ')'

ordered_pattern_CE ::=
	'(' symbol constraint* ')'

template_pattern_CE ::=
	'(' deftemplate_name LHS_slot* ')'

object_pattern_CE ::=
	'(' "object" attribute_constraint* ')'

attribute_constraint ::=
	'(' "is_a" constraint ')'
	| '(' "name" constraint ')'
	| '(' slot_name constraint* ')'

LHS_slot ::=
	single_field_LHS_slot
	| multifield_LHS_slot

single_field_LHS_slot ::=
	'(' slot_name constraint ')'

multifield_LHS_slot ::=
	'(' slot_name constraint* ')'

constraint ::=
	'?'
	| "$?"
	| connected_constraint

connected_constraint ::=
	single_constraint
	| single_constraint '&' connected_constraint
	| single_constraint '|' connected_constraint

single_constraint ::=
	term
	| '~' term

term ::=
	constant
	| single_field_variable
	| multifield_variable
	| ':' function_call
	| '=' function_call

//Defglobal Construct
defglobal_construct ::=
	'(' "defglobal" defmodule_name? global_assignment* ')'

global_assignment ::=
	global_variable '=' expression

global_variable ::= "?*" symbol*

//Deffunction Construct
deffunction_construct ::=
	'(' "deffunction" name comment?
                        '(' regular_parameter* wildcard_parameter? ')'
              action* ')'

regular_parameter ::=
	single_field_variable

//Defgeneric Construct
defgeneric_construct ::=
	'(' "defgeneric" name comment? ')'

//Defmethod Construct
defmethod_construct ::=
	'(' "defmethod" name index? comment?
                   '(' parameter_restriction*
                   wildcard_parameter_restriction? ')'
         action* ')'

parameter_restriction ::=
	single_field_variable
	| '(' single_field_variable type* query? ')'

wildcard_parameter_restriction ::=
	multifield_variable
	| '(' multifield_variable type* query? ')'

type ::=
	class_name

query ::=
	global_variable
	| function_call

//Defclass Construct

defclass_construct ::=
	'(' "defclass" name comment?
                                  '(' "is_a" superclass_name+ ')'
                                   role?
                                   pattern_match_role?
                         slot*
                         handler_documentation* ')'

role ::=
	'(' "role" ("concrete" |"abstract") ')'

pattern_match_role ::=
	'(' "pattern_match" ("reactive" |"non_reactive") ')'

slot ::=
	'(' "slot" name facet* ')'
	| '(' "single_slot" name facet* ')'
	| '(' "multislot" name facet* ')'

facet ::=
	default_facet
	| storage_facet
	| access_facet
	| propagation_facet
	| source_facet
	| pattern_match_facet
	| visibility_facet
	| create_accessor_facet
	| override_message_facet
	| constraint_attribute

default_facet ::=
	'(' "default" ("?DERIVE" |"?NONE" |expression*) ')'
	| '(' "default_dynamic" expression* ')'

storage_facet ::=
	'(' "storage" ("local" |"shared") ')'

access_facet ::=
	'(' "access" ("read_write" |"read_only" |"initialize_only") ')'

propagation_facet ::=
	'(' "propagation" ("inherit" |"no_inherit") ')'

source_facet ::=
	'(' "source" ("exclusive" |"composite") ')'

pattern_match_facet ::=
	'(' "pattern_match" ("reactive" |"non_reactive") ')'

visibility_facet ::=
	'(' "visibility" ("private" |"public") ')'

create_accessor_facet ::=
	'(' "create_accessor" ("?NONE" |"read" |"write" |"read_write") ')'

override_message_facet ::=
	'(' "override_message" ("?DEFAULT" |message_name) ')'

handler_documentation ::=
	'(' "message_handler" name handler_type? ')'

handler_type ::=
	"primary"
	| "around"
	| "before"
	| "after"

//Defmessage_handler Construct
defmessage_handler_construct ::=
	'(' "defmessage_handler" class_name
              message_name handler_type? comment?
                            '(' parameter* wildcard_parameter? ')'
                  action* ')'

parameter ::=
	single_field_variable

wildcard_parameter ::=
	multifield_variable

//Definstances Construct
definstances_construct ::=
	'(' "definstances" definstances_name
                             "active"? comment?
                   instance_template* ')'

instance_template ::=
	'(' instance_definition ')'

instance_definition ::=
	instance_name_expression? "of" class_name_expression slot_override*

slot_override ::=
	'(' slot_name_expression expression* ')'

//Defmodule Construct
defmodule_construct ::=
	'(' "defmodule" module_name comment? port_specification* ')'

port_specification ::=
	'(' "export" port_item ')'
	| '(' "import" module_name port_item ')'

port_item ::=
	"?ALL"
	| "?NONE"
	| port_construct "?ALL"
	| port_construct "?NONE"
	| port_construct construct_name+

port_construct ::=
	"deftemplate"
	| "defclass"
	| "defglobal"
	| "deffunction"
	| "defgeneric"

//Constraint Attributes
constraint_attribute ::=
	type_attribute
	| allowed_constant_attribute
	| range_attribute
	| cardinality_attribute

type_attribute ::=
	'(' "type" type_specification ')'

type_specification ::=
	allowed_type+
	| "?VARIABLE"

allowed_type ::=
	"SYMBOL"
	| "STRING"
	| "LEXEME"
	| "INTEGER"
	| "FLOAT"
	| "NUMBER"
	| "INSTANCE_NAME"
	| "INSTANCE_ADDRESS"
	| "INSTANCE"
	| "EXTERNAL_ADDRESS"
	| "FACT_ADDRESS"

allowed_constant_attribute ::=
	'(' "allowed_symbols" symbol_list ')'
	| '(' "allowed_strings" string_list ')'
	| '(' "allowed_lexemes" lexeme_list ')'
	| '(' "allowed_integers" integer_list ')'
	| '(' "allowed_floats" float_list ')'
	| '(' "allowed_numbers" number_list ')'
	| '(' "allowed_instance_names" instance_name_list ')'
	| '(' "allowed_classes" class_name_list ')'
	| '(' "allowed_values" value_list ')'

symbol_list ::=
	symbol+
	| "?VARIABLE"

string_list ::=
	string+
	| "?VARIABLE"

lexeme_list ::=
	lexeme+
	| "?VARIABLE"

integer_list ::=
	integer+
	| "?VARIABLE"

float_list ::=
	float+
	| "?VARIABLE"

number_list ::=
	number+
	| "?VARIABLE"

instance_name_list ::=
	instance_name+
	| "?VARIABLE"

class_name_list ::=
	class_name+
	| "?VARIABLE"

value_list ::=
	constant+
	| "?VARIABLE"

range_attribute ::=
	'(' "range" range_specification range_specification ')'

range_specification ::=
	number
	| "?VARIABLE"

cardinality_attribute ::=
	'(' "cardinality" cardinality_specification cardinality_specification ')'

cardinality_specification ::=
	integer
	| "?VARIABLE"

//Variables and Expressions
single_field_variable ::=
	"?" variable_symbol

multifield_variable ::=
	"$?" variable_symbol

variable ::=
	single_field_variable
	| multifield_variable
	| global_variable

function_call ::=
	'(' function_name expression* ')'

expression ::=
	constant
	| variable
	| function_call

action ::=
	expression

//...-expression            ::= "An <expression> which returns the type indicated by the ellipsis. For example, <integer_expression> should return an integer."

//Data Types
symbol ::=
	[A-Za-z_][A-Za-z0-9_-]*

string ::=
	'"' ('\\"' | [^"])* '"'

float ::=
	integer exponent
	| integer '.' exponent?
	| '.' unsigned_integer exponent?
	| integer '.' unsigned_integer exponent?

integer ::=
	[+-] digit+

instance_name ::=
	'[' ([^#x5B#x5D \t\r\n])+ ']'

number ::=
	float
	| integer

lexeme ::=
	symbol
	| string

constant ::=
	symbol
	| string
	| integer
	| float
	| instance_name

comment ::=
	';'[^\n]*

whitespace ::= ([ \t\r\n]+ | comment)*

name ::=
	[A-Za-z_][A-Za-z0-9_-]*

variable_symbol ::=
	name //"A symbol beginning with an alphabetic character"

function_name ::=
	name //"Any symbol which corresponds to a system or user defined function, a deffunction name, or a defgeneric name"

//file_name ::=
//	name //"A symbol or string which is a valid file name (including path information) for the operating system under which CLIPS is running"

slot_name ::=
	name //"A valid deftemplate slot name"

//<...-name>         ::= "A <symbol> where the ellipsis indicate what the symbol represents. For example, <rule_name> is a symbol which represents the name of a rule."

digit ::=
	[0-9]

unsigned_integer ::=
	digit+

exponent ::=
	[eE] integer

module_name ::=
	name

definstances_name ::=
	name

class_name ::=
	name

superclass_name ::=
	name

message_name ::=
	name

rule_name ::=
	name

deftemplate_name ::=
	name

deffacts_name ::=
	name

construct_name ::=
	name

defmodule_name ::=
	name

index ::=
	integer

integer_expression ::=
	integer

class_name_expression ::=
	name

instance_name_expression ::=
	name

slot_name_expression ::=
	name

[mingodad]

And here is the failed PEG grammar that can be developed/tested/debugged at https://mingodad.github.io/cpp-peglib/ :

#From: https://www.clipsrules.net/

#Constructs
CLIPS_program <- construct*

construct <-
	deffacts_construct
	/ deftemplate_construct
	/ defglobal_construct
	/ defrule_construct
	/ deffunction_construct
	/ defgeneric_construct
	/ defmethod_construct
	/ defclass_construct
	/ definstances_construct
	/ defmessage_handler_construct
	/ defmodule_construct

#Deffacts Construct
deffacts_construct <-
	'(' "deffacts" deffacts_name comment? RHS_pattern* ')'

#Deftemplate Construct
deftemplate_construct <-
	'(' "deftemplate" deftemplate_name comment? slot_definition* ')'

slot_definition <-
	single_slot_definition
	/ multislot_definition

single_slot_definition <-
	'(' "slot" slot_name template_attribute* ')'

multislot_definition <-
	'(' "multislot" slot_name template_attribute* ')'

template_attribute <-
	default_attribute
	/ constraint_attribute

default_attribute <-
	'(' "default" ("?DERIVE" / "?NONE" / expression*) ')'
	/ '(' "default_dynamic" expression* ')'

#Fact Specification
RHS_pattern <-
	ordered_RHS_pattern
	/ template_RHS_pattern

ordered_RHS_pattern <-
	'(' symbol RHS_field+ ')'

template_RHS_pattern <-
	'(' deftemplate_name RHS_slot* ')'

RHS_slot <-
	single_field_RHS_slot
	/ multifield_RHS_slot

single_field_RHS_slot <-
	'(' slot_name RHS_field ')'

multifield_RHS_slot <-
	'(' slot_name RHS_field* ')'

RHS_field <-
	variable
	/ constant
	/ function_call

#Defrule Construct
defrule_construct <-
	'(' "defrule" rule_name comment? declaration? conditional_element* "=>" action* ')'

declaration <-
	'(' "declare" rule_property+ ')'

rule_property <-
	'(' "salience" integer_expression ')'
	/ '(' "auto_focus" boolean_symbol ')'

boolean_symbol <-
	"TRUE"
	/ "FALSE"

conditional_element <-
	pattern_CE
	/ assigned_pattern_CE
	/ not_CE
	/ and_CE
	/ or_CE
	/ logical_CE
	/ test_CE
	/ exists_CE / forall_CE

pattern_CE <-
	ordered_pattern_CE
	/ template_pattern_CE
	/ object_pattern_CE

assigned_pattern_CE <-
	single_field_variable "-" pattern_CE

not_CE <-
	'(' "not" conditional_element ')'

and_CE <-
	'(' "and" conditional_element+ ')'

or_CE <-
	'(' "or" conditional_element+ ')'

logical_CE <-
	'(' "logical" conditional_element+ ')'

test_CE <-
	'(' "test" function_call ')'

exists_CE <-
	'(' "exists" conditional_element+ ')'

forall_CE <-
	'(' "forall" conditional_element conditional_element+ ')'

ordered_pattern_CE <-
	'(' symbol constraint* ')'

template_pattern_CE <-
	'(' deftemplate_name LHS_slot* ')'

object_pattern_CE <-
	'(' "object" attribute_constraint* ')'

attribute_constraint <-
	'(' "is_a" constraint ')'
	/ '(' "name" constraint ')'
	/ '(' slot_name constraint* ')'

LHS_slot <-
	single_field_LHS_slot
	/ multifield_LHS_slot

single_field_LHS_slot <-
	'(' slot_name constraint ')'

multifield_LHS_slot <-
	'(' slot_name constraint* ')'

constraint <-
	'?'
	/ "$?"
	/ connected_constraint

connected_constraint <-
	single_constraint
	/ single_constraint '&' connected_constraint
	/ single_constraint '|' connected_constraint

single_constraint <-
	term
	/ '~' term

term <-
	constant
	/ single_field_variable
	/ multifield_variable
	/ ':' function_call
	/ '=' function_call

#Defglobal Construct
defglobal_construct <-
	'(' "defglobal" defmodule_name? global_assignment* ')'

global_assignment <-
	global_variable '=' expression

global_variable <- "?*" symbol*

#Deffunction Construct
deffunction_construct <-
	'(' "deffunction" name comment?
                        '(' regular_parameter* wildcard_parameter? ')'
              action* ')'

regular_parameter <-
	single_field_variable

#Defgeneric Construct
defgeneric_construct <-
	'(' "defgeneric" name comment? ')'

#Defmethod Construct
defmethod_construct <-
	'(' "defmethod" name index? comment?
                   '(' parameter_restriction*
                   wildcard_parameter_restriction? ')'
         action* ')'

parameter_restriction <-
	single_field_variable
	/ '(' single_field_variable type* query? ')'

wildcard_parameter_restriction <-
	multifield_variable
	/ '(' multifield_variable type* query? ')'

type <-
	class_name

query <-
	global_variable
	/ function_call

#Defclass Construct

defclass_construct <-
	'(' "defclass" name comment?
                                  '(' "is_a" superclass_name+ ')'
                                   role?
                                   pattern_match_role?
                         slot*
                         handler_documentation* ')'

role <-
	'(' "role" ("concrete" / "abstract") ')'

pattern_match_role <-
	'(' "pattern_match" ("reactive" / "non_reactive") ')'

slot <-
	'(' "slot" name facet* ')'
	/ '(' "single_slot" name facet* ')'
	/ '(' "multislot" name facet* ')'

facet <-
	default_facet
	/ storage_facet
	/ access_facet
	/ propagation_facet
	/ source_facet
	/ pattern_match_facet
	/ visibility_facet
	/ create_accessor_facet
	/ override_message_facet
	/ constraint_attribute

default_facet <-
	'(' "default" ("?DERIVE" / "?NONE" / expression*) ')'
	/ '(' "default_dynamic" expression* ')'

storage_facet <-
	'(' "storage" ("local" / "shared") ')'

access_facet <-
	'(' "access" ("read_write" / "read_only" / "initialize_only") ')'

propagation_facet <-
	'(' "propagation" ("inherit" / "no_inherit") ')'

source_facet <-
	'(' "source" ("exclusive" / "composite") ')'

pattern_match_facet <-
	'(' "pattern_match" ("reactive" / "non_reactive") ')'

visibility_facet <-
	'(' "visibility" ("private" / "public") ')'

create_accessor_facet <-
	'(' "create_accessor" ("?NONE" / "read" / "write" / "read_write") ')'

override_message_facet <-
	'(' "override_message" ("?DEFAULT" / message_name) ')'

handler_documentation <-
	'(' "message_handler" name handler_type? ')'

handler_type <-
	"primary"
	/ "around"
	/ "before"
	/ "after"

#Defmessage_handler Construct
defmessage_handler_construct <-
	'(' "defmessage_handler" class_name
              message_name handler_type? comment?
                            '(' parameter* wildcard_parameter? ')'
                  action* ')'

parameter <-
	single_field_variable

wildcard_parameter <-
	multifield_variable

#Definstances Construct
definstances_construct <-
	'(' "definstances" definstances_name
                             "active"? comment?
                   instance_template* ')'

instance_template <-
	'(' instance_definition ')'

instance_definition <-
	instance_name_expression? "of" class_name_expression slot_override*

slot_override <-
	'(' slot_name_expression expression* ')'

#Defmodule Construct
defmodule_construct <-
	'(' "defmodule" module_name comment? port_specification* ')'

port_specification <-
	'(' "export" port_item ')'
	/ '(' "import" module_name port_item ')'

port_item <-
	"?ALL"
	/ "?NONE"
	/ port_construct "?ALL"
	/ port_construct "?NONE"
	/ port_construct construct_name+

port_construct <-
	"deftemplate"
	/ "defclass"
	/ "defglobal"
	/ "deffunction"
	/ "defgeneric"

#Constraint Attributes
constraint_attribute <-
	type_attribute
	/ allowed_constant_attribute
	/ range_attribute
	/ cardinality_attribute

type_attribute <-
	'(' "type" type_specification ')'

type_specification <-
	allowed_type+
	/ "?VARIABLE"

allowed_type <-
	"SYMBOL"
	/ "STRING"
	/ "LEXEME"
	/ "INTEGER"
	/ "FLOAT"
	/ "NUMBER"
	/ "INSTANCE_NAME"
	/ "INSTANCE_ADDRESS"
	/ "INSTANCE"
	/ "EXTERNAL_ADDRESS"
	/ "FACT_ADDRESS"

allowed_constant_attribute <-
	'(' "allowed_symbols" symbol_list ')'
	/ '(' "allowed_strings" string_list ')'
	/ '(' "allowed_lexemes" lexeme_list ')'
	/ '(' "allowed_integers" integer_list ')'
	/ '(' "allowed_floats" float_list ')'
	/ '(' "allowed_numbers" number_list ')'
	/ '(' "allowed_instance_names" instance_name_list ')'
	/ '(' "allowed_classes" class_name_list ')'
	/ '(' "allowed_values" value_list ')'

symbol_list <-
	symbol+
	/ "?VARIABLE"

string_list <-
	string+
	/ "?VARIABLE"

lexeme_list <-
	lexeme+
	/ "?VARIABLE"

integer_list <-
	integer+
	/ "?VARIABLE"

float_list <-
	float+
	/ "?VARIABLE"

number_list <-
	number+
	/ "?VARIABLE"

instance_name_list <-
	instance_name+
	/ "?VARIABLE"

class_name_list <-
	class_name+
	/ "?VARIABLE"

value_list <-
	constant+
	/ "?VARIABLE"

range_attribute <-
	'(' "range" range_specification range_specification ')'

range_specification <-
	number
	/ "?VARIABLE"

cardinality_attribute <-
	'(' "cardinality" cardinality_specification cardinality_specification ')'

cardinality_specification <-
	integer
	/ "?VARIABLE"

#Variables and Expressions
single_field_variable <-
	"?" variable_symbol

multifield_variable <-
	"$?" variable_symbol

variable <-
	single_field_variable
	/ multifield_variable
	/ global_variable

function_call <-
	'(' function_name expression* ')'

expression <-
	constant
	/ variable
	/ function_call

action <-
	expression

#...-expression            ::= "An <expression> which returns the type indicated by the ellipsis. For example, <integer_expression> should return an integer."

#Data Types
symbol <-
	<[A-Za-z_][A-Za-z0-9_-]*>

string <-
	<'"' ('\\"' / !'"' .)* '"'>

float <-
	<
	integer exponent
	/ integer '.' exponent?
	/ '.' unsigned_integer exponent?
	/ integer '.' unsigned_integer exponent?
	>

integer <-
	<[+-] digit+>

instance_name <-
	<'[' (![\[\] \t\r\n] .)+ ']'>

number <-
	float
	/ integer

lexeme <-
	symbol
	/ string

constant <-
	symbol
	/ string
	/ integer
	/ float
	/ instance_name

comment <-
	';'[^\n]*
	
%whitespace <- ([ \t\r\n]+ / comment)*

name <-
	<[A-Za-z_][A-Za-z0-9_-]*>

variable_symbol <-
	name #"A symbol beginning with an alphabetic character"

function_name <-
	name #"Any symbol which corresponds to a system or user defined function, a deffunction name, or a defgeneric name"

#file_name <-
#	name #"A symbol or string which is a valid file name (including path information) for the operating system under which CLIPS is running"

slot_name <-
	name #"A valid deftemplate slot name"

#<...-name>         ::= "A <symbol> where the ellipsis indicate what the symbol represents. For example, <rule_name> is a symbol which represents the name of a rule."

digit <-
	[0-9]

unsigned_integer <-
	digit+

exponent <-
	[eE] integer

module_name <-
	name

definstances_name <-
	name

class_name <-
	name

superclass_name <-
	name

message_name <-
	name

rule_name <-
	name

deftemplate_name <-
	name

deffacts_name <-
	name

construct_name <-
	name

defmodule_name <-
	name

index <-
	integer

integer_expression <-
	integer

class_name_expression <-
	name

instance_name_expression <-
	name

slot_name_expression <-
	name

[mingodad]

I've got a partially working PEG grammar at https://mingodad.github.io/cpp-peglib/ (select clips parser (partially working) from Examples then click Parse to see an ast for the content in Input source).