Recent changes to State Hierarchy PROTOcol Language

State Hierarchy PROTOcol Language modified by mikerez

mikerez — Mon, 04 Nov 2019 12:26:57 -0000

--- v159
+++ v160
@@ -1,6 +1,6 @@
 #### Briefly ####

-The *SHProto* language describes the *State Machine* for parsing protocol or data format. This state machine is based on *State Hierarchy*. The description is used by *SHProto Compiler* to produce the code for state machine and use it to parse *Input Char Stream*. SHProto supports top-down parsing almost without looking ahead.

+The *SHProto* language describes a *State Machine* for parsing protocol or data format. The State Machine is based on *State Hierarchy*. A description is used by *SHProto Compiler* to produce code for State Machine and use it to parse *Input Char Stream*. SHProto supports top-down parsing almost without looking ahead.

 See also [FAQ].

 #### Main benefits ####
@@ -9,7 +9,6 @@
 * Easy and fast to write new protocol/data parser.
 * Easy and fast to enhance or correct existing parser.
 * Possibility to generate FSM in RAM or code-based FSM!
-* FSM processes input char by char (saves states between chars).

 #### Main conditions ####

State Hierarchy PROTOcol Language modified by mikerez

mikerez — Fri, 21 Sep 2018 07:33:13 -0000

--- v158
+++ v159
@@ -20,7 +20,7 @@

 #### Language basics ####

-* The description consists of *Tokens* divided with space symbols (" ","\\t","\\n","\\r").
+* The description consists of *Tokens* divided by space symbols (" ","\\t","\\n","\\r").
 * Each *token* is a *Node* of *state hierarchy* which is used to build result state machine.
 * The branches are described on different *Lines*.
 * Each *line* has own *Hierarchy Level* which is ruled by its indent.

State Hierarchy PROTOcol Language modified by mikerez

mikerez — Fri, 21 Sep 2018 07:32:10 -0000

--- v157
+++ v158
@@ -5,7 +5,7 @@

 #### Main benefits ####

-* State Machine event-driven runtime!
+* State Machine event-driven runtime.
 * Easy and fast to write new protocol/data parser.
 * Easy and fast to enhance or correct existing parser.
 * Possibility to generate FSM in RAM or code-based FSM!

State Hierarchy PROTOcol Language modified by mikerez

mikerez — Fri, 21 Sep 2018 07:31:41 -0000

--- v156
+++ v157
@@ -1,36 +1,22 @@
 #### Briefly ####

-The *SHProto* language describes the *State Machine* for parsing protocol or data format. This state machine is based on *State Hierarchy* (aka *State Tree*) but some loops are allowed. The description is used by *SHProto Compiler* to produce the *Main Parser Function* which will realize state machine and use it to parse *Input Char Stream*. SHProto supports only top-down parsing almost without looking ahead.

+The *SHProto* language describes the *State Machine* for parsing protocol or data format. This state machine is based on *State Hierarchy*. The description is used by *SHProto Compiler* to produce the code for state machine and use it to parse *Input Char Stream*. SHProto supports top-down parsing almost without looking ahead.

 See also [FAQ].

 #### Main benefits ####

 * State Machine event-driven runtime!
-* Easy and fast to write new protocol/data parser (if you have experience).
-* Easy and fast to enhance or correct existing parser (even if you are newbie).
-* The FSM realized in RAM should be **VERY** fast!
-* FSM could process input char by char (saves states between chars).
+* Easy and fast to write new protocol/data parser.
+* Easy and fast to enhance or correct existing parser.
+* Possibility to generate FSM in RAM or code-based FSM!
+* FSM processes input char by char (saves states between chars).

 #### Main conditions ####

-* The input data flow is char (=1 byte=8 bit) based stream (*input char stream*).
-* The input stream could be limited or unlimited.
-* At any moment previous data and knowledges say how to parse next data.
-* Suppose you are waiting for some data or events to be extracted as a result.
-* Easily parses text protocols like HTTP, SMTP, POP3, IMAP, FTP, SNTP, SIP but binary capability should be done too.
-* Compiler will produce \<proto_name>.cc and \<proto_name>.h (and may be other source files) containing parser class with *state machine* building method *bool build_tree(shproto_node*)*, main parser's method *bool parse_input(char * input, unsigned len)*, *\<proto_name>_state* class, *\<proto_name>_output* class and base classes.
-
-#### Very simple example (description vs *state machine*) ####
-
-![Simple example image](https://sourceforge.net/p/shproto/wiki/Pictures/attachment/shproto-1.png)
-
-Will match any input lines like
-"Give me a pie.\\n"
-"Give me bigmac.\\n"
-"Give me an icecream.\\n"
-"Give me an icecream with chocolate.\\n"
-"Give me an icecream with chocolate and banana.\\n"
-and will call corresponding C++ function.
+* Input data flow is chars (=1 byte=8 bit) based stream (*input char stream*).
+* Input stream can be limited or unlimited.
+* Easily parses text protocols like HTTP, SMTP, POP3, IMAP, FTP, SNTP, SIP etc.
+* Compiler produces \<proto_name>.cc and \<proto_name>.h .

 #### Language basics ####

@@ -62,27 +48,27 @@

 Modificator | Description
 ------------|------------
-* | *node* could be repeated zero or many times
-+ | *node* could be repeated at least one time
+* | *node* may be repeated zero or many times
++ | *node* may be repeated at least one time
 ? | *node* will be optionally present

 #### Branching ####

 1. The branching begins from creating new *line* and increasing indent.
 +  You can describe several branches on the same indent and they all will be cheked when *state machine* will reach branching point.
-+  Any branch could have sub-branches.
++  Any branch may have sub-branches.
 +  By decreasing indent level you mean there are no more sub-branches linked to the previous branch.
 +  Being once entered the branch changes the parser's state and no state rollback will be possible (except handling by *default* token).
 +  Parser will try appropriate branches from top to bottom, depending on expected symbol or behavior of the first branch's C++ *node*. 
 +  The top branches are with zero indent and at least one such branch should present in the beginning of the file (first non empty *line*).
 +  The *line* cant have indent less than previous if such indent was not present earlier.
-+  The *external branch* could be described standalone after the main tree and empty line. This branch should start from \<@ALIAS> and should be called so.
-+  C++ code *node* will match any input symbol and will be entered if will not return *false*.
++  The *external branch* can be described standalone after the main tree and empty line. This branch should start from \<@ALIAS> and should be called so.
++  C++ code *node* matches any input symbol and will be entered if will not return *false*.
 +  Parser must use char-based indexes embedded in *nodes* to seek for appropriate node.
 +  The *default* node should get all input symbols that was passed to sub-branch before unexpected symbol was found (adding *default* will slow-down the selection).
 +  The '\\' token will logically place branches to the parent's level.

-For example lets describe fast index-based parsing of some HTTP headers:
+This example describes fast index-based parsing of some HTTP headers:

     :::bash
     'Content-' \
@@ -95,9 +81,9 @@
 

 #### Aliasing ####

-1. Any branching point could be aliased by adding \<\@alias name> to the end of line before branches begins.
-+  Alias could be used to declare *external branch* by adding empty *line* and \<\@alias name> after main tree or previous *external branch*. The sub-branches of *external branch* (alias) should go with increased indent.
-+  *External branch* could be called from main tree or other *external branch* and after *$$* token state machine will be returned to the place the call was done from.
+1. Any branching point may be aliased by adding \<\@alias name> to the end of line before branches begins.
++  Alias may be used to declare *external branch* by adding empty *line* and \<\@alias name> after main tree or previous *external branch*. The sub-branches of *external branch* (alias) should go with increased indent.
++  *External branch* may be called from main tree or other *external branch* and after *$$* token state machine will be returned to the place the call was done from.
 +  All other cases of calling aliases (including calling branch from itselve, calling main tree from branch) just do jumping and the calling place will not be saved.
 +  The *token* $ in *external branch* will return state machine to the main *tree* root. 

</proto_name></proto_name></proto_name></proto_name></proto_name></proto_name>

State Hierarchy PROTOcol Language modified by mikerez

mikerez — Thu, 08 Sep 2016 12:49:45 -0000

--- v155
+++ v156
@@ -141,4 +141,4 @@
 * [BINARY1] parser example 1
 * [SQL] parser (draft!!!)

-![State Hierarchy](https://sourceforge.net/p/shproto/wiki/Pictures/attachment/137.png)
+![State Hierarchy](https://sourceforge.net/p/shproto/wiki/Pictures/attachment/tree.png)

State Hierarchy PROTOcol Language modified by mikerez

mikerez — Thu, 08 Sep 2016 12:46:28 -0000

--- v154
+++ v155
@@ -140,3 +140,5 @@
 * [MIME] parser example
 * [BINARY1] parser example 1
 * [SQL] parser (draft!!!)
+
+![State Hierarchy](https://sourceforge.net/p/shproto/wiki/Pictures/attachment/137.png)

State Hierarchy PROTOcol Language modified by mikerez

mikerez — Fri, 15 May 2015 09:35:50 -0000

--- v153
+++ v154
@@ -51,7 +51,7 @@
 \[\^jhg,a-z,\\t\\x18\\\\\\\-] | alternative states *node*  (just inlines several branches in one *line*), inherits syntax from regexp, (real symbol '-' should be always back-quoted for now)
 var:type(parameters) | *Variable node* (handles any apropriate symbols for *variable* type) - will be saved in variable in parser's state; please see [SHProto variable types] 
 { printf("text"); return false; } | c++ code *node* handles any symbol and passes it through to the next *node*; returning false will stop switching to this state and parser will search for other case if exists; the following local variables are available in C++ expression: *char* chr (current *input stream* char), *shproto_state* \* state (contains ALL *variables* declared in the *tree*)
-@ALIAS | aliasing any branching point in hierarchy, always should be at the end of line, or standalone (*NOT A NODE*)
+@ALIAS | aliasing any branching point in hierarchy (*NOT A NODE*)
 <ALIAS> | call to any aliased branching point (*NOT A NODE*)
 $ | call to the hierarchy top (*NOT A NODE*)
 $$ | exit from the external branch to the place it was called from (*NOT A NODE*)

State Hierarchy PROTOcol Language modified by mikerez

mikerez — Fri, 15 May 2015 09:35:01 -0000

--- v152
+++ v153
@@ -51,7 +51,7 @@
 \[\^jhg,a-z,\\t\\x18\\\\\\\-] | alternative states *node*  (just inlines several branches in one *line*), inherits syntax from regexp, (real symbol '-' should be always back-quoted for now)
 var:type(parameters) | *Variable node* (handles any apropriate symbols for *variable* type) - will be saved in variable in parser's state; please see [SHProto variable types] 
 { printf("text"); return false; } | c++ code *node* handles any symbol and passes it through to the next *node*; returning false will stop switching to this state and parser will search for other case if exists; the following local variables are available in C++ expression: *char* chr (current *input stream* char), *shproto_state* \* state (contains ALL *variables* declared in the *tree*)
-<@ALIAS> | aliasing any branching point in hierarchy, always should be at the end of line, or standalone (*NOT A NODE*)
+@ALIAS | aliasing any branching point in hierarchy, always should be at the end of line, or standalone (*NOT A NODE*)
 <ALIAS> | call to any aliased branching point (*NOT A NODE*)
 $ | call to the hierarchy top (*NOT A NODE*)
 $$ | exit from the external branch to the place it was called from (*NOT A NODE*)

State Hierarchy PROTOcol Language modified by mikerez

mikerez — Fri, 15 May 2015 09:34:10 -0000

--- v151
+++ v152
@@ -51,8 +51,8 @@
 \[\^jhg,a-z,\\t\\x18\\\\\\\-] | alternative states *node*  (just inlines several branches in one *line*), inherits syntax from regexp, (real symbol '-' should be always back-quoted for now)
 var:type(parameters) | *Variable node* (handles any apropriate symbols for *variable* type) - will be saved in variable in parser's state; please see [SHProto variable types] 
 { printf("text"); return false; } | c++ code *node* handles any symbol and passes it through to the next *node*; returning false will stop switching to this state and parser will search for other case if exists; the following local variables are available in C++ expression: *char* chr (current *input stream* char), *shproto_state* \* state (contains ALL *variables* declared in the *tree*)
-\<\@ALIAS> | aliasing any branching point in hierarchy, always should be at the end of line, or standalone (*NOT A NODE*)
-\<ALIAS> | call to any aliased branching point (*NOT A NODE*)
+<@ALIAS> | aliasing any branching point in hierarchy, always should be at the end of line, or standalone (*NOT A NODE*)
+<ALIAS> | call to any aliased branching point (*NOT A NODE*)
 $ | call to the hierarchy top (*NOT A NODE*)
 $$ | exit from the external branch to the place it was called from (*NOT A NODE*)
 \  | at the end of branch logically disarms indent of following sub-branches

State Hierarchy PROTOcol Language modified by mikerez

mikerez — Mon, 30 Mar 2015 08:24:42 -0000

--- v150
+++ v151
@@ -1,6 +1,6 @@
 #### Briefly ####

-The *SHProto* language describes the *State Machine* for parsing protocol or data format. This state machine is based on *State Hierarchy* (aka *State Tree*) but some loops are allowed. The description is used by *SHProto Compiler* to produce the *Main Parser Function* which will realize state machine and use it to parse *Input Char Stream*. SHProto supports only to-down parsing almost without looking ahead.

+The *SHProto* language describes the *State Machine* for parsing protocol or data format. This state machine is based on *State Hierarchy* (aka *State Tree*) but some loops are allowed. The description is used by *SHProto Compiler* to produce the *Main Parser Function* which will realize state machine and use it to parse *Input Char Stream*. SHProto supports only top-down parsing almost without looking ahead.

 See also [FAQ].

 #### Main benefits ####