Strip block comments: Difference between revisions

{{task|Text processing}}

[[Category:String manipulation]]

 

A block comment begins with a   ''beginning delimiter''   and ends with a   ''ending delimiter'',   including the delimiters.   These delimiters are often multi-character sequences.

;Extra credit:

Ensure that the stripping code is not hard-coded to the particular delimiters described above, but instead allows the caller to specify them.   (If your language supports them,   [[Optional parameters|optional parameters]]   may be useful for this.)

 

{{Template:Strings}}

<br><br>

 

=={{header|Ada}}==

strip.adb:

with Ada.Strings.Unbounded;

with Ada.Text_IO;

end loop;

Ada.Text_IO.Close (File => File);

output:

<pre>

=={{header|ALGOL W}}==

Handles non-nested block comments, the start and end delimiters are specified as parameters. Comments inside string-literals are retained. The string quote and escape characters are specified as parameters.

% strips block comments from a source %

% the source is read from standard input and the result written to %

% text stripBlockComments for C-style source %

stripBlockComments( "/*", "*/", """", "'", "\" )

{{out}}

<pre>

 

=={{header|AutoHotkey}}==

(

/**

closeC:=RegExReplace(closeC,"(\*|\^|\?|\\|\+|\.|\!|\{|\}|\[|\]|\$|\|)","\$0")

;Display final result

<pre>

 

function something() {

}</pre>

 

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

outfile$ = "C:\stripped.c"

CLOSE #infile%

CLOSE #outfile%

Output file:

<pre>

 

=={{header|C}}==

#include <string.h>

#include <stdlib.h>

free(s);

return 0;

;Usage:

Specify an input file via the first command line argument, and optionally specify comment opening and closing delimiters with the next two args, or defaults of /* and */ are assumed.

 

=={{header|C sharp|C#}}==

 

class Program

return sampleText;

}

 

=={{header|C++}}==

#include <iostream>

#include <iterator>

return 1 ;

}

Output:

<pre>

 

=={{header|Clojure}}==

(let [args (conj {:delim ["/*" "*/"]} (apply hash-map args)) ; This is the standard way of doing keyword/optional arguments in Clojure

[opener closer] (:delim args)]

(= (apply str hdtxt) closer) (recur out resttxt (dec delim-count))

(= delim-count 0)(recur (str out (first txt)) (rest txt) delim-count)

<pre>user> (comment-strip "This /* is */ some /* /* /* */ funny */ */ text")

hdtxt= Th resttxt=is /* is */ some /* /* /* */ funny */ */ text out= txt=This /* is */ some /* /* /* */ funny */ */ text delim-count=0

 

=={{header|D}}==

 

string[2] separateComments(in string txt,

 

showResults(ex2, separateComments(ex2, `#|;`, `[\n\r]|$`));

{{out}}

<pre>===Original text:

===The stripped comments:

# and bananas; and bananas </pre>

 

=={{header|F_Sharp|F#}}==

Using .NET's regex counter feature to match nested comments.

If comments here are nested, they have to be correctly balanced.

open System.Text.RegularExpressions

 

let balancedC = balancedComments "/*" "*/"

printfn "%s" (balancedC.Replace(sample, ""))

Output

<pre>

=={{header|Factor}}==

===Regexp implementation===

: strip-block-comments ( string -- string )

R/ /\*.*?\*\// "" re-replace ;

===Manual implementation===

USING: kernel io accessors strings math sequences locals

io.streams.string multiline prettyprint ;

 

MAIN: test-strip-block-comments

 

=={{header|Fortran}}==

A feature of Fortran's character comparison is that trailing spaces are ignored, so that "x " and "x " and "x" are all deemed equal. Unfortunate choices of starting and ending delimiter texts can be made if they contain characters in common.

 

SUBROUTINE UNBLOCK(THIS,THAT) !Removes block comments bounded by THIS and THAT.

Copies from file INF to file OUT, record by record, except skipping null output records.

 

END !All open files are closed on exit..

 

Output: the report is "16 read, 8 written." And in the output file appears...

 

F90 allows the syntax END SUBROUTINE UNBLOCK (and insists on it within a MODULE) but F77 does not, otherwise the statement could have been <code>CALL UNBLOCK("SUBROUTINE","END SUBROUTINE")</code> which would be rather more structured.

 

=={{header|Go}}==

For the extra credit: No optional parameters in Go, but documented below is an efficient technique for letting the caller specify the delimiters.

 

import (

function something() {

}`))

 

=={{header|Groovy}}==

/**

* Some comments

"""

 

 

=={{header|Haskell}}==

THE FOLLOWING SOLUTION IS WRONG, as it does not take string literals into account. For example:

Comment delimiters can be changed by calling stripComments with different start and end parameters.

 

stripComments :: String -> String -> String -> String

| otherwise = inComment $ tail xs

 

Output:

<pre>

=={{header|Icon}} and {{header|Unicon}}==

If one is willing to concede that the program file will fit in memory, then the following code works:

every (unstripped := "") ||:= !&input || "\n" # Load file as one string

write(stripBlockComment(unstripped,"/*","*/"))

return result || tab(0)

}

Otherwise, the following handles an arbitrary length input:

every writes(stripBlockComment(!&input,"/*","*/"))

end

else fail

}

 

=={{header|J}}==

1 0 0

0 2 0

2 3 2

0 2 2

Example data:

/**

* Some comments

function something() {

}

Example use:

function subroutine() {

function something() {

Here is a version which allows the delimiters to be passed as an optional left argument as a pair of strings:

('/*';'*/') stripp y

:

marks=. (+./(-i._1+#open,close)|."0 1 open E. y) - close E.&.|. y

y #~ -. (+._1&|.) (1 <. 0 >. +)/\.&.|. marks

 

=={{header|Java}}==

 

public class StripBlockComments{

}

}

 

=={{header|jq}}==

 

The filter <tt>strip_block_comments/2</tt> as defined here does not attempt to recognize comments-within-comments.

def deregex:

reduce ("\\\\", "\\*", "\\^", "\\?", "\\+", "\\.",

gsub( (open|deregex) + ".*?" + (close|deregex); ""; "m") ;

 

'''Invocation''':

$ jq -s -R -r -f Strip_block_comments.jq sample_text_for_stripping.txt

{{works with|Julia|0.6}}

{{trans|Python}}

"Strips first nest of block comments"

 

end

 

 

{{out}}

 

=={{header|Kotlin}}==

 

val sample = """

println(stripBlockComments(sample))

println(stripBlockComments(sample2, "``{", "``}"))

 

{{out}}

}

 

</pre>

 

=={{header|Liberty BASIC}}==

CRLF$ =chr$( 13) +chr$( 10)

 

end if

next i

<pre>

 

=={{header|Lua}}==

It is assumed, that the code is in the file "Text1.txt".

 

fp = io.open( filename, "r" )

 

stripped = string.gsub( str, "/%*.-%*/", "" )

 

 

->

function something() {

 

=={{header|MATLAB}} / {{header|Octave}}==

while(1)

ix1 = strfind(str, startmarker);

end;

end;

Output:

<pre>

=={{header|Nim}}==

{{trans|Python}}

 

let i = txt.find(delim.l)

 

result = if i > 0: txt[0 ..< i] else: ""

*/

function something() {

<pre>NON-NESTED BLOCK COMMENT EXAMPLE:

 

 

=={{header|Perl}}==

use strict ;

use warnings ;

close FH ;

$code =~ s,/\*.*?\*/,,sg ;

Output:

<pre>

 

=={{header|Phix}}==

/**

*/

}

{{out}}

<pre>

 

=={{header|PHP}}==

function strip_block_comments( $test_string ) {

$pattern = "/^.*?(\K\/\*.*?\*\/)|^.*?(\K\/\*.*?^.*\*\/)$/mXus";

}

" ) . "'";

 

{{out}}

 

=={{header|PicoLisp}}==

(while (echo "/*")

Output:

<pre>

 

=={{header|PL/I}}==

strip: procedure options (main); /* 8/1/2011 */

declare text character (80) varying;

end;

 

 

=={{header|Prolog}}==

Prolog enables grammar rules via the DCG that are ideally suited for this task .

 

 

:- system:set_prolog_flag(double_quotes,codes) .

zero_or_more(_) --> ! .

 

 

{{out}}

=={{header|PureBasic}}==

Solution using regular expressions. A procedure to stripBlocks() procedure is defined that will strip comments between any two delimeters.

Static specialChars.s = "[\^$.|?*+()"

Protected output.s, nextChar.s, i, countChar = Len(text)

Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()

CloseConsole()

Sample output:

<pre>--- source ---

=={{header|Python}}==

The code has comment delimeters as an argument and will also strip ''nested'' block comments.

'Strips first nest of block comments'

while deliml in txt:

txt = _commentstripper(txt, delim)

;Tests and sample output

print('\nNON-NESTED BLOCK COMMENT EXAMPLE:')

sample = ''' /**

if __name__ == '__main__':

 

<pre>

=={{header|Racket}}==

 

#lang at-exp racket

 

}

})

 

(Outputs the expected text...)

=={{header|Raku}}==

(formerly Perl 6)

 

sub sample {

function something() {

}

Output:

<pre>

 

=={{header|REXX}}==

* Split comments

* This program ignores comment delimiters within literal strings

 

oc: Return lineout(oic,oc)

Input:

<pre>

 

=={{header|Ring}}==

example = "123/*456*/abc/*def*/789"

end

see example2 + nl

 

=={{header|Ruby}}==

while start_idx = str.index(comment_start)

end_idx = str.index(comment_end, start_idx + comment_start.length) + comment_end.length - 1

END_OF_STRING

 

outputs

<pre>

 

=={{header|Scala}}==

def strip1(x: String, s: String = "/*", e: String = "*/") =

val a = x indexOf s

val b = x indexOf (e, a + s.length)

if (a == -1 || b == -1) x

else strip2(x.take(a) + x.drop(b + e.length), s, e)

case -1 => x

case i => x.indexOf(e, i + s.length) match {

case j => strip2(x.take(i) + x.drop(j + e.length), s, e)

}

 

=={{header|Seed7}}==

can be used to replace unnested comments.

 

 

const proc: main is func

begin

writeln(replace2(stri, "/*", "*/", " "));

Output:

<pre>

=={{header|Sidef}}==

For extra credit, it allows the caller to redefine the delimiters.

var re = Regex.new(beg.escape + '.*?' + end.escape, 's');

code.gsub(re, '');

}

 

 

=={{header|Swift}}==

 

 

func stripBlocks(from str: String, open: String = "/*", close: String = "*/") -> String {

"""

 

 

{{out}}

 

=={{header|Tcl}}==

# Convert the delimiters to REs by backslashing all non-alnum characters

set openAsRE [regsub -all {\W} $openDelimiter {\\&}]

# Now remove the blocks using a dynamic non-greedy regular expression

regsub -all "$openAsRE.*?$closeAsRE" $string ""

Demonstration code:

* Some comments

* longer comments here that we can parse.

function something() {

}

Output:

<pre>

 

=={{header|TUSCRIPT}}==

$$ MODE DATA

$$ script=*

d=FILE("destfile")

TRACE *d

Output:

<pre>

=={{header|VBA}}==

Stripping block comments might look easy ...

'multi line comments

'and what if there are string literals with these delimeters?

Debug.Print String$(60, "-")

Debug.Print t

------------------------------------------------------------

/**

=={{header|Wren}}==

{{trans|Go}}

if (start == "" || end == "") {

start = "/*"

 

var stripC = stripper.call("", "")

 

{{out}}

 

=={{header|XProfan}}==

Parameters string inhalt, beg_delim, end_delim

Declare long start, ende, anzahl

Print Text

WaitKey

{{out}}

<pre>

 

=={{header|zkl}}==

while(xy:=text.span(a,b,True)){ x,y:=xy; text=text[0,x] + text[x+y,*] }

text

The span method takes two tokens and matches the shortest or longest balanced match (if True). It assumes there are no escape characters (such as \ or ""). So we just repeatedly strip out the longest balanced comments until there aren't any left (span returns the empty list). If a comment was unbalanced, span would fail but this code doesn't check that and just assumes no more matches.

{{out}}