How to express [a-zA-Z0-9] for one char?

Question

I need to convert this c++ function into python:

bool validText(const char *text)
{
    bool result = false;
    while (*text)
    {
        if ((*text) & 0x80)
        {
            result = true;
            text++; 
        }
        else if ((*text >= 'a' && *text <= 'z' || *text >= 'A' && *text <= 'Z') ||
                 ((*text) >= '0' && (*text) <= '9'))
        {
            result = true;
        }
        text++;
    }
    return result;
}

I understand that it is checking whether the string consists of chars with its int value is >= 128 or within the range of [a-zA-Z0-9].

My python version looks like:

    def validText(text):

    valid = False
    for s in text:
        c = ord(s)
        if c >= 128:
            valid = True
            break
        elif( (c>='a' and c<='z') or (c>='A' and c<='Z') (c>='0' and c<='9') ):
            valid = True
            break
    
    return valid

I have two questions for this:

1. Is my understanding of the c++ right?
2. Is the python version right?

I can't find a proper string to test this, so not sure whether I am doing the right thing.

Answer 1

The first check (*text) & 0x80 is simply if the char is non ascii (https://www.asciitable.com/), so greater-than-or-equal to 128 would work.

The program itself appears to be checking if there exists any single non-ascii or alpha numeric chars in the character set (isalnum will not work!). The C++ program, however does not short circuit the loop (it will always iterate through the entire null terminated string input, even when it has found a character that meets the condition). It is odd that the program skips characters if the first criteria (non ascii) is met (extra text++). If you wanted a matching python port, you could modify how you iterate:

def valid_text(text):
    valid = False
    i = 0
    while i < len(text):
        s = text[i]
        c = ord(s)
        if c >= 128:
            valid = True
            i += 1
        elif ord('z') <= c >= ord('a') or ord('Z') <= c >= ord('A') or ord('0') >= c <= ord('9'):
            valid = True
        i += 1
    return valid

Logically your approach should work, but you need to be sure to do ord-to-ord comparison!

Here are some run examples using python 3.6:

>>> valid_text('////')
False
>>> valid_text('////a')
True
>>> valid_text('/a///')
True
>>> valid_text('/Ω///')
True

Short circuit example:

    def valid_text(text):
        i = 0
        while i < len(text):
            s = text[i]
            c = ord(s)
            if c >= 128:
                return True
            elif ord('z') <= c >= ord('a') or ord('Z') <= c >= ord('A') or ord('0') >= c <= ord('9'):
                return True
            i += 1
        return False

Example without Ord:

    def valid_text(text):
        i = 0
        while i < len(text):
            c = text[i]
            if c >= '\x80':
                return True
            elif 'a' <= c <= 'z' or 'A' <= c <= 'Z' or '0' <= c <= '9':
                return True
            i += 1
        return False

Answer 2

You can use text.isalnum()

'asadslk adçs'.isalnum()
False

'azAZ90'.isalnum()
True

Answer 3

First, you should realize that any character that has its highest bit set (i.e c & 0x80 == 0x80) is nonascii.

To answer your questions:

1. Your understanding seems correct; to be precise, the C++ code checks if the string contains any character is alphanumeric or non-ascii. However, the C++ code probably contains a bug: for any non-ascii character seen, it advances the pointer once, and at the end advances the pointer again. This can cause the pointer to be advanced too many times, should the last character be nonascii.

2. The Python code looks correct based on your understanding, however a much better solution would just be to replace the code with (assuming Python >= 3.7):

def validText(text):
    return bool(text and (not text.isascii() or any(t.isalnum() for t in text)))

This does what the appears to be the intent of the C++ code:

for ex in [
    "",
    "\n",
    "\na",
    "a\n",
    "1\n",
    "\n1",
    "\n漢",
    "漢\n"
]:
    print(f"'{ex}': {validText(ex)}")
    print("----")

Output

'': False
----
'
': False
----
'
a': True
----
'a
': True
----
'1
': True
----
'
1': True
----
'
漢': True
----
'漢
': True
----