Класс FunctionType

import string
 
 
class Token:
    __slots__ = 'toknum', 'tokval'
 
    Id = 1
    LeftParen = 2   # (
    RightParen = 3  # )
    LeftBrace = 4   # {
    RightBrace = 5  # }
    ConstString = 6
    KeywordFunction = 7
    KeywordPrint = 8
 
    def __init__(self, toknum, tokval):
        self.toknum = toknum
        self.tokval = tokval
 
    def __str__(self):
        return 'toknum={} tokval="{}"'.format(self.toknum, self.tokval)
 
 
class Tokenizer:
    __slots__ = 's', 'cur', 'linenum', 'rownum'
    
    def __init__(self, s):
        self.s = s
        self.cur = 0
        self.linenum = 1
        self.rownum = 0
 
    def __iter__(self):
        return self
 
    def __next__(self) -> Token:
        if self.cur >= len(self.s):
            raise StopIteration
 
        try:
            while True:
                if self.s[self.cur] in ' \t':
                    self.cur += 1
                    self.rownum += 1
                    continue
                if self.s[self.cur] == '\n':
                    self.cur += 1
                    self.rownum = 0
                    self.linenum += 1
                    continue
                break
        except IndexError:
            raise StopIteration
 
        if self.s[self.cur] == '(':
            self.cur += 1
            self.rownum += 1
            return Token(Token.LeftParen, '(')
 
        if self.s[self.cur] == ')':
            self.cur += 1
            self.rownum += 1
            return Token(Token.RightParen, ')')
 
        if self.s[self.cur] == '{':
            self.cur += 1
            self.rownum += 1
            return Token(Token.LeftBrace, '{')
 
        if self.s[self.cur] == '}':
            self.cur += 1
            self.rownum += 1
            return Token(Token.RightBrace, '}')
 
        # Id
        if self.s[self.cur] in string.ascii_letters:
            v = []
            v.append(self.s[self.cur])
            self.cur += 1
            self.rownum += 1
            while True:
                if self.s[self.cur] not in string.ascii_letters + string.digits:
                    tokval = ''.join(v)
                    toknum = {
                        'function': Token.KeywordFunction,
                        'print': Token.KeywordPrint,
                    }.get(tokval, Token.Id)
                    return Token(toknum, tokval)
                v.append(self.s[self.cur])
                self.cur += 1
                self.rownum += 1
 
        if self.s[self.cur] == "'":
            v = []
            self.cur += 1
            self.rownum += 1
            while True:
                if self.s[self.cur] == "'":
                    self.cur += 1
                    self.rownum += 1
                    return Token(Token.ConstString, ''.join(v))
                v.append(self.s[self.cur])
                self.cur += 1
                self.rownum += 1
 
        self.raise_error('неизвестный символ: "{}"'.format(self.s[self.cur]))
 
    def raise_error(self, msg):
        raise ValueError('{}:{}: {}'.format(self.linenum, self.rownum, msg))
 
 
class Var:
    __slots__ = 'num', 'val'
 
    Func = 1
 
    def __init__(self, num, val):
        self.num = num
        self.val = val
 
 
def main(text):
    globals_var = {}
    
    t = Tokenizer(text)
    while True:
        try:
            token = next(t)
        except StopIteration:
            break
        
        if token.toknum == Token.KeywordFunction:
            name, value = declare_func(t)
            if name in globals_var:
                t.raise_error('id "{}" уже был объявлен раньше'.format(name))
            globals_var[name] = value
            continue
 
        if token.toknum == Token.Id:
            name = token.tokval
 
            # [id]()
            token = next(t)
            if token.toknum != Token.LeftParen:
                t.raise_error('ожидался (, найдено "{}"'.format(token.tokval))
 
            token = next(t)
            if token.toknum != Token.RightParen:
                t.raise_error('ожидался ), найдено "{}"'.format(token.tokval))
 
            if name not in globals_var:
                t.raise_error('функция "{}" не найдена'.format(name))
            call_func(t, globals_var[name].val)
            continue
 
        t.raise_error('ожидалось "function" или id, найдено "{}"'.format(token.tokval))
    print('all ok')
 
 
def declare_func(t):
    # function [id]() { … }
    token = next(t)
    if token.toknum != Token.Id:
        t.raise_error('ожидался id, найдено "{}"'.format(token.tokval))
    func_name = token.tokval
    
    token = next(t)
    if token.toknum != Token.LeftParen:
        t.raise_error('ожидался (, найдено "{}"'.format(token.tokval))
 
    token = next(t)
    if token.toknum != Token.RightParen:
        t.raise_error('ожидался ), найдено "{}"'.format(token.tokval))
 
    token = next(t)
    if token.toknum != Token.LeftBrace:
        t.raise_error('ожидался {, найдено "{}"'.format(token.tokval))
 
    func_body = []
    while True:
        token = next(t)
        if token.toknum == Token.RightBrace:
            return func_name, Var(Var.Func, func_body)
        func_body.append(token)
 
 
def call_func(t, func_body):
    i = 0
    while True:
        try:
            token = func_body[i]
        except IndexError:
            break
        if token.toknum != Token.KeywordPrint:
            t.raise_error('ожидался print, найдено "{}"'.format(token.tokval))
 
        i += 1
        token = func_body[i]
        if token.toknum != Token.ConstString:
            t.raise_error('ожидался constString, найдено "{}"'.format(token.tokval))
        print(token.tokval)
        i += 1
        
 
 
text = '''\
function foo() {
   print 'hello'
}
foo()
foo()
'''
main(text)