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

      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