support for ANSI colors

[yonizaf]

I'm using ANSI colors (ANSI escape codes) rather heavily in my scripts. Running them in nppexec console results in a lot of unreadable gibberish.

I it's possible to support colors it would be great. If not, at least filter out the codes, maybe?

[d0vgan]

I'll consider it.
( In fact, I hate when people say "I'll consider it" - because you never know what they actually mean by that: will they just think about it or will they implement it at some point of time :) ).
I think the next version of NppExec will be able to filter the color codes. To do that, however, minimal logic of parsing the colors must be implemented anyway - I mean, at least for detection of the beginning and ending of the color code fragment of the output text.

[d0vgan]

I have to say I am far from being familiar with ANSI colors, and the (ANSI escape codes) does not look clear to me.
Is there any sort of "formula" that describes all the possible ESC-sequences? By this "formula" I mean something like the following:

• 2-byte seqences in form of 0x1B {x}, where {x} is in the range of [{start}, {end}] (question: what are the values of {start} and {end}?)
• 3-byte seqences in form of 0x1B {x1} {x2}, where {x1} is in the range of [{start}, {end}] (question: what are the values of {start} and {end}?)
• n-byte sequences in a form of 0x1B {start} {any number of bytes here} {end} (question: what are the possible values of {start} and {end}?)
• n-byte sequences in a form of 0x1B {start_n} {exactly n bytes here} (question: what are the possible values of {start_n}?)
• any other possible combination I did not think of

[d0vgan]

I mean, I need to completely understand where any possible ESC-sequence begins and where exactly it ends - and only basing on this information I'll be able to do any processing, even simple filtering of the ESC-sequences.

[d0vgan]

Added ability to remove ANSI escape sequences in https://github.com/d0vgan/nppexec/tree/develop .
Please check the latest binaries under https://sourceforge.net/projects/npp-plugins/files/NppExec/NppExec%20Plugin%20v0.6%20RC3-RC4%20%28dev%29/

[d0vgan]

Included in NppExec v0.6.1: the ability to remove ANSI escape sequences (npe_console e1).

[pidgeon777]

If one day NppExec will be able to colourize even parts of its lines (maybe compatibility with ANSI colours?), it would be very nice.

[CombatWorthyWombat]

I too, heavily utilise escape chars in my code and imports, and would love to see support for it. That would probably push me over to making np++ with NppExec my primary IDE.

Many thanks for the work so far :)

With regard to trying to parse ANSI esc sequences in a manner that is exclusive but permissive, the VT100 terminal might be a good one to imitate - its decently known and would allow you to fit into a "known variant" of escape character support while staying on the bare-bones side of things. This is the user manual: https://vt100.net/docs/vt100-ug/chapter3.html

It also includes what you might have been looking for "formula" wise:

Valid ANSI Mode Control Sequences
Definitions

The following listing defines the basic elements of the ANSI mode control sequences. A more complete listing appears in Appendix A.

Control Sequence Introducer (CSI)
    An escape sequence that provides supplementary controls and is itself a prefix affecting the interpretation of a limited number of contiguous characters. In the VT100 the CSI is ESC [.
Parameter

        A string of zero or more decimal characters which represent a single value. Leading zeroes are ignored. The decimal characters have a range of 0 (608) to 9 (718).
        The value so represented.

Numeric Parameter
    A parameter that represents a number, designated by Pn.
Selective Parameter
    A parameter that selects a subfunction from a specified list of subfunctions, designated by Ps. In general, a control sequence with more than one selective parameter causes the same effect as several control sequences, each with one selective parameter, e.g., CSI Psa; Psb; Psc F is identical to CSI Psa F CSI Psb F CSI Psc F.
Parameter String
    A string of parameters separated by a semicolon (738).
Default
    A function-dependent value that is assumed when no explicit value, or a value of 0, is specified.
Final character
    A character whose bit combination terminates an escape or control sequence.

With the following example:

Control sequence to turn off all character attributes, and then turn on underscore and blink attributes (SGR). ESC [ 0 ; 4 ; 5 m:

SEQUENCE:

OCTAL REPRESENTATION OF SEQUENCE:

On a separate note, and if you want to see some in actual code, this is a small snippet of a CLI tool that uses ANSI esc codes:

#=======================================
#-----------------COLOUR----------------
#=======================================

RESET = '\033[0m'

class colour:
    colour_map = {
        'black': 16, 'red': 196, 'green': 28, 'yellow': 226, 'blue': 21, etc ect ect 
    }

    def __getattr__(self, name):
        # handle changing function names
        def colour_function(text):
            code_or_name = self.parse_colour(name)
            if code_or_name is type(int):
                code_or_name = str(code_or_name)
            elif code_or_name is None:
                raise ValueError(f"unknown colour: {name}")
            return f"\033[38;5;{code_or_name}m" + f"{text}" + RESET
        return colour_function

    def parse_colour(self, code_or_name):

        if code_or_name in self.colour_map:
            return self.colour_map[code_or_name]
        elif code_or_name[4:].isdigit() and int(code_or_name[4:]) <= 256:
            if code_or_name[:4] == "ansi":
                return int(code_or_name[4:])
            else:
                raise ValueError(f"unknown colour format: {code_or_name[:4]}")
        return None

    def ansi_remind(self):
        for i in range(0, 256):
            colour = f"\033[38;5;{i:03d}m"
            if i == 17 or i == 231:
                carriage = "\n" + ("=") * 71 + "\n"
            elif (i + 1) % 18 == 0 and (i + 1) < 18 * 13:
                carriage = "\n"
            else:
                carriage = " "
            print(colour + f"{i:03d}" + RESET, end=carriage)

c = colour()

#=======================================
#----------------VERBOSE----------------
#=======================================

verbose = True

if verbose == True:
    
    def verbose_print(*args):
        for arg in args:
            print(arg, "\n", end="")
else:
    def verbose_print(*args):
        pass

if __name__ == "__main__":
    c.ansi_remind()
    print(c.ansi196("red text here"))
    verbose_print(c.ansi111("verbose text here"))

Please excuse the sloppy coding, I'm new to the majority of this :)

[d0vgan]

Yes, this is something I tried to do in this branch:
https://github.com/d0vgan/nppexec/tree/feature/pseudo-console

Unfortunately, the resulting cursor position were frequently positioned at an unexpected place and I could not figure out why. So eventually I've given up.

Another potential way would be to integrate a libvterm library into NppExec and see whether it gives better results. One might open the NppExec’s sources in a code editor with AI-driven assistant - such as the Cursor editor - and explicitly ask the AI assistant about the integration with libvterm. NppExec already contains the parts of the code around g_pseudoCon and m_hPseudoCon as the starting point.
If someone feels the power to do that, this would be highly welcome and I’ll provide the additional technical details.
I don't feel a wish to do it myself because it requires certain efforts - and I don't want to be in a situation when a lot of time has been spent just to find out that this approach does not work. I mean, I already was in such situation with the "pseudo-console" branch, and I don't want to experience another failure.