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.
    • 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