syntax_ids:
<id0>
<id1>
...

rules:

node_type
: [node_type/slex_id/slex_tag/direct_string] [node_type/slex_id/slex_tag/direct_string] ...
=> [operation] $0 $1 ...
: [node_type/slex_id/slex_tag/direct_string] [node_type/slex_id/slex_tag/direct_string] ...
=> [operation] $0 $1 ...
;

#
# $0 and $1 here means selected node/segment from matching element list.
#

Operations

new_node <syntax-id>: create a new node and attach to parent node
append_as_child: append selected
skip: do nothing

Sample:


syntax_ids:

binary_expr
function_call_expr
argument_list
variable

rules:

expr
: expr binary_operator expr
=> new_node binary_expr $0 $1 $2
: name "(" argument_list ")"
=> new_node function_call_expr $0 
| name
=> new_node variable $0
;

argument_list
:argument_list "," expr
=> append_as_child $2
:expr
=> new_node argument_list $0
;

Usage

scc [options] <input_file> [options]

input file usually ends with `.scc`

Options:

-o <output> output file/output folder
-l <language> specify target language, e.g: c, c#, csharp
-h <header> output header file (will separate output implementation and definitions when language is c or c++. Note: c++ is currently not supported.)
-ns <namespace> specify namespace (supported languages only). Default is `scc_generated`, `SCCGenerated`, `io.creeperlv.scc.generated` for applicable language.
-class <class_name> specify class name (supported languages only). Default is `scc`, `SCC`.
-prefix <function_prefix> specify prefix for functions. Default is `scc_` for languages does not support namespace/class, `` (empty string) for languages support namespace/class.
-data_type <data_type_name> specify the name of the syntax node data type.
-slex-h <header> specify header file slex generated.
-slex-ns <namespace> specify namespace used in slex.
-slex-class <class_name> specify class name used in slex.
-slex-prefix <function_prefix> specify function prefix used in slex.
-slex-data_type <data_type_name> specify segment data type used in slex.

Data Type Name Table

Language	Type Name
C	scc_syntax_node
C#	SyntaxNode

Generated parser

All usages here uses default settings

C99

Usage sample:

void scc_sample(FILE* f, char* file_name){
	
	struct slex_segment* head;
	const char* str="<some_inputs>";
	if(slex_file(f, file_name, &head)){
		//Success
		struct scc_syntax_node* root;
		if(scc_parse(head,&root)){
			//Success
		}
	}
	slex_free(head);
}

API and defined data types:

typedef struct scc_syntax_node_enclosure{
	enum scc_syntax_node_type;
	void* data;
}scc_syntax_node_enclosure;
typedef enum scc_syntax_node_type{
	scc_node, scc_segment
}scc_syntax_node_type;
typedef struct scc_syntax_node{
	enum scc_syntax_id;
	char* syntax_name;
	scc_syntax_node_enclosure* children;
	uint64_t child_count;
	scc_syntax_node* parent;
} scc_syntax_node;

typedef enum scc_syntax_id{
    default,<generated from rule file>
}scc_syntax_id;
char scc_parse(slex_segment* head, scc_syntax_node** output);
char scc_free(scc_syntax_node* root);

C#

APIs:

using SLexGenerated;
namesapce SCCGenerated{
	public class SCC{
			public bool Parse(Segment head, out SyntaxNode Root);
	}
	
    public enum SyntaxId{
		Default,<Generated-from-rule-file>
    }
	public class SyntaxNodeEnclosure{
		public SyntaxNode? Node;
		public Segment? Segment;
		public EnclosureType EnclosureType;
	}
	public enum EnclosureType{
		Node, Segment
	}
	public class SyntaxNode{
		public SyntaxNode? Parent;
		public string SyntaxName;
		public SyntaxId Id;
		public List<SyntaxNodeEnclosure> Children;
	}
}