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