Community
    • Login

    PHP function list and abstract functions

    Scheduled Pinned Locked Moved Notepad++ & Plugin Development
    19 Posts 3 Posters 8.3k Views
    Loading More Posts
    • Oldest to Newest
    • Newest to Oldest
    • Most Votes
    Reply
    • Reply as topic
    Log in to reply
    This topic has been deleted. Only users with topic management privileges can see it.
    • Florent PagèsF
      Florent Pagès @chcg
      last edited by

      @chcg said:

      @MAPJe71 A task for you?

      Why not !

      1 Reply Last reply Reply Quote 0
      • chcgC
        chcg
        last edited by

        See https://github.com/notepad-plus-plus/notepad-plus-plus/pull/3393, @MAPJe71 has a expertise for functionlist changes.

        1 Reply Last reply Reply Quote 0
        • Florent PagèsF
          Florent Pagès
          last edited by

          For the problem with heredoc in php

          		<parser
          			id         ="php_syntax"
          			displayName="PHP"
          			commentExpr="(?s:/\*.*?\*/)|(?m-s://.*?$)"
          		>
          

          I have changed it into

          		<parser
          			id         ="php_syntax"
          			displayName="PHP"
          			commentExpr="\x3C{3}[\x20\t]*(\w+)(\r|\n|\r\n)(.|[\s])*?\1;(\r|\n|\r\n)|(?s:/\*.*?\*/)|(?m-s://.*?$)"
          		>
          

          seems to work.

          MAPJe71M 1 Reply Last reply Reply Quote 0
          • MAPJe71M
            MAPJe71 @Florent Pagès
            last edited by

            @Florent-Pagès could you try this:

            				commentExpr="(?x)                                               # free-spacing (see `RegEx - Pattern Modifiers`)
            								(?s:\x2F\x2A.*?\x2A\x2F)                        # Multi Line Comment
            							|	(?m-s:(?:\x23|\x2F{2}).*$)                      # Single Line Comment 1 and 2
            							|	(?s:\x22(?:[^\x22\x24\x5C]|\x5C.)*\x22)         # String Literal - Double Quoted
            							|	(?s:\x27(?:[^\x27\x5C]|\x5C.)*\x27)             # String Literal - Single Quoted
            							|	(?:                                             # Here Document
            									\x3C{3}(?'HDID'[A-Za-z_\x7F-\xFF][\w\x7F-\xFF]*)[^\r\n]*(?:\r?\n|\n?\r)
            									(?s:.*?)
            									(?:\r?\n|\n?\r)\k'HDID'                     # close with exactly the same identifier, in the first column
            								)
            							|	(?:                                             # Now Document
            									\x3C{3}\x27(?'NDID'[A-Za-z_\x7F-\xFF][\w\x7F-\xFF]*)\x27[^\r\n]*(?:\r?\n|\n?\r)
            									(?s:.*?)
            									(?:\r?\n|\n?\r)\k'NDID'                     # close with exactly the same identifier, in the first column
            								)
            							"
            
            1 Reply Last reply Reply Quote 0
            • Florent PagèsF
              Florent Pagès
              last edited by

              Seems to work. I will test longer this week.

              1 Reply Last reply Reply Quote 0
              • Florent PagèsF
                Florent Pagès
                last edited by

                I have found a bad case but not with heredoc, the class does not appear in functionlist :

                <?php
                 class Bad  {
                function RsdTitle() { 
                	$i = 1;
                	$table = 5;
                	if (TRUE) {
                		switch ($i) {
                			case 1: return "Jeu pour apprendre la table de multiplication par {$table}";
                			case 2: return "Jeu pour apprendre la table de {$table} d'addition";
                		}
                	}
                	return "Jeu avec les tables de multiplications https://motsbleus.pages-informatique.com/jeu-tables-multiplications.html"; 	
                }	
                 } 
                ?>
                
                1 Reply Last reply Reply Quote 0
                • Florent PagèsF
                  Florent Pagès
                  last edited by

                  Where to find the regex reference manual used in the functionlist?

                  MAPJe71M 1 Reply Last reply Reply Quote 0
                  • MAPJe71M
                    MAPJe71 @Florent Pagès
                    last edited by

                    @Florent-Pagès Please try this parser:

                    			<parser
                    				displayName="PHP - Personal Home Page / PHP Hypertext Preprocessor"
                    				id         ="php_syntax"
                    				commentExpr="(?x)                                               # free-spacing (see `RegEx - Pattern Modifiers`)
                    								(?s:\x2F\x2A.*?\x2A\x2F)                        # Multi Line Comment
                    							|	(?m-s:(?:\x23|\x2F{2}).*$)                      # Single Line Comment 1 and 2
                    							|	(?s:\x22(?:[^\x22\x24\x5C]|\x5C.)*\x22)         # String Literal - Double Quoted
                    							|	(?s:\x27(?:[^\x27\x5C]|\x5C.)*\x27)             # String Literal - Single Quoted
                    							|	(?:                                             # Here Document
                    									\x3C{3}(?'HDID'[A-Za-z_\x7F-\xFF][\w\x7F-\xFF]*)[^\r\n]*(?:\r?\n|\n?\r)
                    									(?s:.*?)
                    									(?:\r?\n|\n?\r)\k'HDID'                     # close with exactly the same identifier, in the first column
                    								)
                    							|	(?:                                             # Now Document
                    									\x3C{3}\x27(?'NDID'[A-Za-z_\x7F-\xFF][\w\x7F-\xFF]*)\x27[^\r\n]*(?:\r?\n|\n?\r)
                    									(?s:.*?)
                    									(?:\r?\n|\n?\r)\k'NDID'                     # close with exactly the same identifier, in the first column
                    								)
                    							"
                    			>
                    				<classRange
                    					mainExpr    ="(?x)                                          # free-spacing (see `RegEx - Pattern Modifiers`)
                    							(?(DEFINE)                                          # definition of sub-routines
                    								(?'VALID_ID'
                    									\b(?!(?-i:                                  # keywords (case-sensitive), not to be used as identifier
                    										a(?:bstract|nd|rray|s)
                    									|	b(?:ool|reak)
                    									|	c(?:a(?:llable|se|tch)|l(?:ass|one)|on(?:st|tinue))
                    									|	d(?:e(?:clare|fault)|ie|o)
                    									|	e(?:cho|lse(?:if)?|mpty|nd(?:declare|for(?:each)?|if|switch|while)|val|x(?:it|tends))
                    									|	f(?:alse|loat|inal|or(?:each)?|unction)
                    									|	g(?:lobal|oto)
                    									|	i(?:f|mplements|n(?:clude(?:_once)?|st(?:anceof|eadof)|t(?:erface)?)|sset)
                    									|	list
                    									|	mixed
                    									|	n(?:amespace|ew|u(?:ll|meric))
                    									|	o(?:r|bject)
                    									|	p(?:r(?:i(?:nt|vate)|otected)|ublic)
                    									|	re(?:quire(?:_once)?|turn)
                    									|	s(?:t(?:atic|ring)|witch)
                    									|	t(?:hrow|r(?:ait|ue|y))
                    									|	u(?:nset|se)
                    									|	var
                    									|	while
                    									|	xor
                    									|	__(?:halt_compiler|(?:CLASS|DIR|F(?:ILE|UNCTION)|LINE|METHOD|NAMESPACE|TRAIT)__)
                    									)\b)
                    									[A-Za-z_\x7F-\xFF][\w\x7F-\xFF]*            # valid character combination for identifiers
                    								)
                    								(?'INTERFACE_LIST'
                    									\s+(?:\x5C|(?&amp;VALID_ID))+
                    									(?:
                    										\s*,
                    										\s*(?:\x5C|(?&amp;VALID_ID))+
                    									)*
                    								)
                    							)
                    							(?m-i)                                              # ^ and $ match at line-breaks, case-sensitive
                    							^\h*                                                # optional leading white-space at start-of-line
                    							(?:
                    								(?:(?-i:abstract|final)\s+)?                    # optional class entry type
                    								(?-i:class)\s+
                    								\K                                              # discard text matched so far
                    								(?&amp;VALID_ID)                                # identifier used as class name
                    								(?:                                             # optional extends-from-class
                    									\s+(?-i:extends)
                    									\s+(?:\x5C|(?&amp;VALID_ID))+
                    								)?
                    								(?:                                             # optional implements-class/interfaces
                    									\s+(?-i:implements)
                    									(?&amp;INTERFACE_LIST)
                    								)?
                    							|
                    								(?-i:interface)\s+
                    								\K                                              # discard text matched so far
                    								(?&amp;VALID_ID)                                # identifier used as interface name
                    								(?:                                             # optional extends-from list
                    									\s+(?-i:extends)
                    									(?&amp;INTERFACE_LIST)
                    								)?
                    							|
                    								(?-i:trait)\s+
                    								\K                                              # discard text matched so far
                    								(?&amp;VALID_ID)                                # identifier used as trait name
                    							)
                    							\s*\{
                    						"
                    					openSymbole ="\{"
                    					closeSymbole="\}"
                    				>
                    					<className>
                    						<nameExpr expr="[A-Za-z_\x7F-\xFF][\w\x7F-\xFF]*" />
                    					</className>
                    					<function
                    						mainExpr="(?x)                                          # free-spacing (see `RegEx - Pattern Modifiers`)
                    								(?m-i)                                          # ^ and $ match at line-breaks, case-sensitive
                    								^\h*                                            # optional leading white-space at start-of-line
                    								(?:(?-i:                                        # field modifiers
                    										p(?:r(?:ivate|otected)|ublic)           # - access modifiers
                    									|	abstract|final|static                   # - ...
                    								)\s+)*                                          # require a white-space separator
                    								(?-i:function)\s+
                    								\K                                              # discard text matched so far
                    								(?:\x26\s*)?                                    # optionally a reference
                    								(?'VALID_ID'                                    # valid identifier, use as subroutine
                    									\b(?!(?-i:                                  # keywords (case-sensitive), not to be used as identifier
                    										a(?:bstract|nd|rray|s)
                    									|	b(?:ool|reak)
                    									|	c(?:a(?:llable|se|tch)|l(?:ass|one)|on(?:st|tinue))
                    									|	d(?:e(?:clare|fault)|ie|o)
                    									|	e(?:cho|lse(?:if)?|mpty|nd(?:declare|for(?:each)?|if|switch|while)|val|x(?:it|tends))
                    									|	f(?:alse|loat|inal|or(?:each)?|unction)
                    									|	g(?:lobal|oto)
                    									|	i(?:f|mplements|n(?:clude(?:_once)?|st(?:anceof|eadof)|t(?:erface)?)|sset)
                    									|	list
                    									|	mixed
                    									|	n(?:amespace|ew|u(?:ll|meric))
                    									|	o(?:r|bject)
                    									|	p(?:r(?:i(?:nt|vate)|otected)|ublic)
                    									|	re(?:quire(?:_once)?|turn)
                    									|	s(?:t(?:atic|ring)|witch)
                    									|	t(?:hrow|r(?:ait|ue|y))
                    									|	u(?:nset|se)
                    									|	var
                    									|	while
                    									|	xor
                    									|	__(?:halt_compiler|(?:CLASS|DIR|F(?:ILE|UNCTION)|LINE|METHOD|NAMESPACE|TRAIT)__)
                    									)\b)
                    									[A-Za-z_\x7F-\xFF][\w\x7F-\xFF]*            # valid character combination for identifiers
                    								)                                               # identifier used as method name
                    								\s*\(                                           # start of function parameters
                    								[^{]*\{                                         # start of function body
                    							"
                    					>
                    						<functionName>
                    							<funcNameExpr expr="(?:\x26\s*)?[A-Za-z_\x7F-\xFF][\w\x7F-\xFF]*\s*\((?:[^/{]|/(?![*/]))*" />
                    							<!-- comment out the following node to display the method with parameters -->
                    							<funcNameExpr expr="(?:\x26\s*)?[A-Za-z_\x7F-\xFF][\w\x7F-\xFF]*" />
                    						</functionName>
                    					</function>
                    				</classRange>
                    				<function
                    					mainExpr="(?x)                                              # free-spacing (see `RegEx - Pattern Modifiers`)
                    							(?m-i)                                              # ^ and $ match at line-breaks, case-sensitive
                    							^\h*                                                # optional leading white-space at start-of-line
                    							(?-i:function)\s+
                    							\K                                                  # discard text matched so far
                    							(?:\x26\s*)?                                        # optionally a reference
                    							(?'VALID_ID'                                        # valid identifier, use as subroutine
                    								\b(?!(?-i:                                      # keywords (case-sensitive), not to be used as identifier
                    									a(?:bstract|nd|rray|s)
                    								|	b(?:ool|reak)
                    								|	c(?:a(?:llable|se|tch)|l(?:ass|one)|on(?:st|tinue))
                    								|	d(?:e(?:clare|fault)|ie|o)
                    								|	e(?:cho|lse(?:if)?|mpty|nd(?:declare|for(?:each)?|if|switch|while)|val|x(?:it|tends))
                    								|	f(?:alse|loat|inal|or(?:each)?|unction)
                    								|	g(?:lobal|oto)
                    								|	i(?:f|mplements|n(?:clude(?:_once)?|st(?:anceof|eadof)|t(?:erface)?)|sset)
                    								|	list
                    								|	mixed
                    								|	n(?:amespace|ew|u(?:ll|meric))
                    								|	o(?:r|bject)
                    								|	p(?:r(?:i(?:nt|vate)|otected)|ublic)
                    								|	re(?:quire(?:_once)?|turn)
                    								|	s(?:t(?:atic|ring)|witch)
                    								|	t(?:hrow|r(?:ait|ue|y))
                    								|	u(?:nset|se)
                    								|	var
                    								|	while
                    								|	xor
                    								|	__(?:halt_compiler|(?:CLASS|DIR|F(?:ILE|UNCTION)|LINE|METHOD|NAMESPACE|TRAIT)__)
                    								)\b)
                    								[A-Za-z_\x7F-\xFF][\w\x7F-\xFF]*                # valid character combination for identifiers
                    							)                                                   # identifier used as function name
                    							\s*\(                                               # start of function parameters
                    							[^{]*\{                                             # start of function body
                    						"
                    				>
                    					<functionName>
                    						<nameExpr expr="(?:\x26\s*)?[A-Za-z_\x7F-\xFF][\w\x7F-\xFF]*\s*\((?:[^/{]|/(?![*/]))*" />
                    						<!-- comment out the following node to display the function with its parameters -->
                    						<nameExpr expr="(?:\x26\s*)?[A-Za-z_\x7F-\xFF][\w\x7F-\xFF]*" />
                    					</functionName>
                    				</function>
                    			</parser>
                    
                    1 Reply Last reply Reply Quote 0
                    • Florent PagèsF
                      Florent Pagès
                      last edited by

                      Not working in this case but i focus on the problem : the “$i” in the switch/case.

                      	<?php
                      	class Bad  {
                      		function RsdTitle() { 
                      			$i = 1;
                      		   switch ($i) {
                      				case 1:
                      				$a =  "$i";
                      				break;
                      			}
                      			return "1";   
                      		}    
                      	} 
                      	?>
                      

                      So i tried to change your parser in the commentExpr this way :

                                           # orignal line->  |   (?s:\x22(?:[^\x22\x24\x5C]|\x5C.)*\x22)         # String Literal - Double Quoted
                                              |   (?s:\x22(?:[^\x22\x5C]|\x5C.)*\x22)         # String Literal - Double Quoted
                      

                      It seem to work for me but i am not sure of what i did. (the \x24 is $ caracter)

                      1 Reply Last reply Reply Quote 0
                      • MAPJe71M
                        MAPJe71
                        last edited by

                        The original regex would not consider "$i" a double quoted string literal. That’s incorrect (my bad), your adaption is correct.

                        1 Reply Last reply Reply Quote 0
                        • Florent PagèsF
                          Florent Pagès
                          last edited by

                          Thanks a lot, it works great !

                          I hope it will be included into the next release.

                          1 Reply Last reply Reply Quote 0
                          • MAPJe71M
                            MAPJe71
                            last edited by

                            I will include it in Function List Update 4.

                            1 Reply Last reply Reply Quote 0
                            • Florent PagèsF
                              Florent Pagès
                              last edited by

                              Super. Functions list is very useful for me.

                              I hope “functions list” will be improved: showing line number , jumping on class name or synch selection on edit location.

                              1 Reply Last reply Reply Quote 0
                              • Florent PagèsF
                                Florent Pagès
                                last edited by

                                I have change a line in functionList.xml in the php parser :

                                							# Old line: [^{]*\{                                       # start of function body
                                                            (?:[^{;]*(?:\{|;))                                         # start of function body
                                

                                It fixes the problem that an abstract function doesn’t have body.

                                1 Reply Last reply Reply Quote 0
                                • Florent PagèsF
                                  Florent Pagès
                                  last edited by

                                  full PHP parser

                                  		<!-- ========================================================= [ PHP ] -->
                                  		<!-- PHP - Personal Home Page / PHP Hypertext Preprocessor             -->
                                  
                                        <parser
                                              displayName="PHP - Personal Home Page / PHP Hypertext Preprocessor"
                                              id         ="php_syntax"
                                              commentExpr="(?x)                                               # free-spacing (see `RegEx - Pattern Modifiers`)
                                                              (?s:\x2F\x2A.*?\x2A\x2F)                        # Multi Line Comment  x2F -> '/'  x2A -> '*'  
                                                          |   (?m-s:(?:\x23|\x2F{2}).*$)                      # Single Line Comment 1 # and 2 //
                                                        #  |   (?s:\x22(?:[^\x22\x24\x5C]|\x5C.)*\x22)         # String Literal - Double Quoted
                                                          |   (?s:\x22(?:[^\x22\x5C]|\x5C.)*\x22)         # String Literal - Double Quoted
                                                          |   (?s:\x27(?:[^\x27\x5C]|\x5C.)*\x27)             # String Literal - Single Quoted
                                                          |   (?:                                             # Here Document
                                                                  \x3C{3}(?'HDID'[A-Za-z_\x7F-\xFF][\w\x7F-\xFF]*)[^\r\n]*(?:\r?\n|\n?\r)
                                                                  (?s:.*?)
                                                                  (?:\r?\n|\n?\r)\k'HDID'                     # close with exactly the same identifier, in the first column
                                                              )
                                                          |   (?:                                             # Now Document
                                                                  \x3C{3}\x27(?'NDID'[A-Za-z_\x7F-\xFF][\w\x7F-\xFF]*)\x27[^\r\n]*(?:\r?\n|\n?\r)
                                                                  (?s:.*?)
                                                                  (?:\r?\n|\n?\r)\k'NDID'                     # close with exactly the same identifier, in the first column
                                                              )
                                                          "
                                          >
                                              <classRange
                                                  mainExpr    ="(?x)                                          # free-spacing (see `RegEx - Pattern Modifiers`)
                                                          (?(DEFINE)                                          # definition of sub-routines
                                                              (?'VALID_ID'
                                                                  \b(?!(?-i:                                  # keywords (case-sensitive), not to be used as identifier
                                                                      a(?:bstract|nd|rray|s)
                                                                  |   b(?:ool|reak)
                                                                  |   c(?:a(?:llable|se|tch)|l(?:ass|one)|on(?:st|tinue))
                                                                  |   d(?:e(?:clare|fault)|ie|o)
                                                                  |   e(?:cho|lse(?:if)?|mpty|nd(?:declare|for(?:each)?|if|switch|while)|val|x(?:it|tends))
                                                                  |   f(?:alse|loat|inal|or(?:each)?|unction)
                                                                  |   g(?:lobal|oto)
                                                                  |   i(?:f|mplements|n(?:clude(?:_once)?|st(?:anceof|eadof)|t(?:erface)?)|sset)
                                                                  |   list
                                                                  |   mixed
                                                                  |   n(?:amespace|ew|u(?:ll|meric))
                                                                  |   o(?:r|bject)
                                                                  |   p(?:r(?:i(?:nt|vate)|otected)|ublic)
                                                                  |   re(?:quire(?:_once)?|turn)
                                                                  |   s(?:t(?:atic|ring)|witch)
                                                                  |   t(?:hrow|r(?:ait|ue|y))
                                                                  |   u(?:nset|se)
                                                                  |   var
                                                                  |   while
                                                                  |   xor
                                                                  |   __(?:halt_compiler|(?:CLASS|DIR|F(?:ILE|UNCTION)|LINE|METHOD|NAMESPACE|TRAIT)__)
                                                                  )\b)
                                                                  [A-Za-z_\x7F-\xFF][\w\x7F-\xFF]*            # valid character combination for identifiers
                                                              )
                                                              (?'INTERFACE_LIST'
                                                                  \s+(?:\x5C|(?&amp;VALID_ID))+
                                                                  (?:
                                                                      \s*,
                                                                      \s*(?:\x5C|(?&amp;VALID_ID))+
                                                                  )*
                                                              )
                                                          )
                                                          (?m-i)                                              # ^ and $ match at line-breaks, case-sensitive
                                                          ^\h*                                                # optional leading white-space at start-of-line
                                                          (?:
                                                              (?:(?-i:abstract|final)\s+)?                    # optional class entry type
                                                              (?-i:class)\s+
                                                              \K                                              # discard text matched so far
                                                              (?&amp;VALID_ID)                                # identifier used as class name
                                                              (?:                                             # optional extends-from-class
                                                                  \s+(?-i:extends)
                                                                  \s+(?:\x5C|(?&amp;VALID_ID))+
                                                              )?
                                                              (?:                                             # optional implements-class/interfaces
                                                                  \s+(?-i:implements)
                                                                  (?&amp;INTERFACE_LIST)
                                                              )?
                                                          |
                                                              (?-i:interface)\s+
                                                              \K                                              # discard text matched so far
                                                              (?&amp;VALID_ID)                                # identifier used as interface name
                                                              (?:                                             # optional extends-from list
                                                                  \s+(?-i:extends)
                                                                  (?&amp;INTERFACE_LIST)
                                                              )?
                                                          |
                                                              (?-i:trait)\s+
                                                              \K                                              # discard text matched so far
                                                              (?&amp;VALID_ID)                                # identifier used as trait name
                                                          )
                                                          \s*\{
                                                      "
                                                  openSymbole ="\{"
                                                  closeSymbole="\}"
                                              >
                                                  <className>
                                                      <nameExpr expr="[A-Za-z_\x7F-\xFF][\w\x7F-\xFF]*" />
                                                  </className>
                                                  <function
                                                      mainExpr="(?x)                                          # free-spacing (see `RegEx - Pattern Modifiers`)
                                                              (?m-i)                                          # ^ and $ match at line-breaks, case-sensitive
                                                              ^\h*                                            # optional leading white-space at start-of-line
                                                              (?:(?-i:                                        # field modifiers
                                                                      p(?:r(?:ivate|otected)|ublic)           # - access modifiers
                                                                  |   abstract|final|static                   # - ...
                                                              )\s+)*                                          # require a white-space separator
                                                              (?-i:function)\s+
                                                              \K                                              # discard text matched so far
                                                              (?:\x26\s*)?                                    # optionally a reference
                                                              (?'VALID_ID'                                    # valid identifier, use as subroutine
                                                                  \b(?!(?-i:                                  # keywords (case-sensitive), not to be used as identifier
                                                                      a(?:bstract|nd|rray|s)
                                                                  |   b(?:ool|reak)
                                                                  |   c(?:a(?:llable|se|tch)|l(?:ass|one)|on(?:st|tinue))
                                                                  |   d(?:e(?:clare|fault)|ie|o)
                                                                  |   e(?:cho|lse(?:if)?|mpty|nd(?:declare|for(?:each)?|if|switch|while)|val|x(?:it|tends))
                                                                  |   f(?:alse|loat|inal|or(?:each)?|unction)
                                                                  |   g(?:lobal|oto)
                                                                  |   i(?:f|mplements|n(?:clude(?:_once)?|st(?:anceof|eadof)|t(?:erface)?)|sset)
                                                                  |   list
                                                                  |   mixed
                                                                  |   n(?:amespace|ew|u(?:ll|meric))
                                                                  |   o(?:r|bject)
                                                                  |   p(?:r(?:i(?:nt|vate)|otected)|ublic)
                                                                  |   re(?:quire(?:_once)?|turn)
                                                                  |   s(?:t(?:atic|ring)|witch)
                                                                  |   t(?:hrow|r(?:ait|ue|y))
                                                                  |   u(?:nset|se)
                                                                  |   var
                                                                  |   while
                                                                  |   xor
                                                                  |   __(?:halt_compiler|(?:CLASS|DIR|F(?:ILE|UNCTION)|LINE|METHOD|NAMESPACE|TRAIT)__)
                                                                  )\b)
                                                                  [A-Za-z_\x7F-\xFF][\w\x7F-\xFF]*            # valid character combination for identifiers
                                                              )                                               # identifier used as method name
                                                              \s*\(                                           # start of function parameters
                                                              (?:[^{;]*(?:\{|;))                              # start of function body  or abstract function without body
                                                          "
                                                  >
                                                      <functionName>
                                                          <funcNameExpr expr="(?:\x26\s*)?[A-Za-z_\x7F-\xFF][\w\x7F-\xFF]*\s*\((?:[^/{]|/(?![*/]))*" />							
                                                          <!-- comment out the following node to display the method with parameters -->
                                                          <funcNameExpr expr="(?:\x26\s*)?[A-Za-z_\x7F-\xFF][\w\x7F-\xFF]*" />  
                                                      </functionName>
                                                  </function>
                                              </classRange>
                                              <function
                                                  mainExpr="(?x)                                              # free-spacing (see `RegEx - Pattern Modifiers`)
                                                          (?m-i)                                              # ^ and $ match at line-breaks, case-sensitive
                                                          ^\h*                                                # optional leading white-space at start-of-line
                                                          (?-i:function)\s+
                                                          \K                                                  # discard text matched so far
                                                          (?:\x26\s*)?                                        # optionally a reference
                                                          (?'VALID_ID'                                        # valid identifier, use as subroutine
                                                              \b(?!(?-i:                                      # keywords (case-sensitive), not to be used as identifier
                                                                  a(?:bstract|nd|rray|s)
                                                              |   b(?:ool|reak)
                                                              |   c(?:a(?:llable|se|tch)|l(?:ass|one)|on(?:st|tinue))
                                                              |   d(?:e(?:clare|fault)|ie|o)
                                                              |   e(?:cho|lse(?:if)?|mpty|nd(?:declare|for(?:each)?|if|switch|while)|val|x(?:it|tends))
                                                              |   f(?:alse|loat|inal|or(?:each)?|unction)
                                                              |   g(?:lobal|oto)
                                                              |   i(?:f|mplements|n(?:clude(?:_once)?|st(?:anceof|eadof)|t(?:erface)?)|sset)
                                                              |   list
                                                              |   mixed
                                                              |   n(?:amespace|ew|u(?:ll|meric))
                                                              |   o(?:r|bject)
                                                              |   p(?:r(?:i(?:nt|vate)|otected)|ublic)
                                                              |   re(?:quire(?:_once)?|turn)
                                                              |   s(?:t(?:atic|ring)|witch)
                                                              |   t(?:hrow|r(?:ait|ue|y))
                                                              |   u(?:nset|se)
                                                              |   var
                                                              |   while
                                                              |   xor
                                                              |   __(?:halt_compiler|(?:CLASS|DIR|F(?:ILE|UNCTION)|LINE|METHOD|NAMESPACE|TRAIT)__)
                                                              )\b)
                                                              [A-Za-z_\x7F-\xFF][\w\x7F-\xFF]*                # valid character combination for identifiers
                                                          )                                                   # identifier used as function name
                                                          \s*\(                                               # start of function parameters
                                                          [^{]*\{                                             # start of function body 
                                                      "
                                              >
                                                  <functionName>
                                                      <nameExpr expr="(?:\x26\s*)?[A-Za-z_\x7F-\xFF][\w\x7F-\xFF]*\s*\((?:[^/{]|/(?![*/]))*" />
                                                      <!-- comment out the following node to display the function with its parameters -->
                                                      <!-- <nameExpr expr="(?:\x26\s*)?[A-Za-z_\x7F-\xFF][\w\x7F-\xFF]*" /> -->
                                                  </functionName>
                                              </function>
                                          </parser>
                                  
                                  1 Reply Last reply Reply Quote 3
                                  • Florent PagèsF
                                    Florent Pagès
                                    last edited by

                                    I join GitHub, but I not sure of what I did for submit this piece of code.

                                    https://github.com/TutoInformatik/notepad-plus-plus/pulls?q=is%3Apr+is%3Aclosed

                                    1 Reply Last reply Reply Quote 0
                                    • First post
                                      Last post
                                    The Community of users of the Notepad++ text editor.
                                    Powered by NodeBB | Contributors