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

      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