WARNING: C:Program Filesadbmsstrg_engdone.py:66: Rule 'change_tname' defined, but not used
WARNING: C:Program Filesadbmsstrg_engdone.py:70: Rule 'create_db' defined, but not used
WARNING: C:Program Filesadbmsstrg_engdone.py:74: Rule 'create_tb' defined, but not used
WARNING: C:Program Filesadbmsstrg_engdone.py:78: Rule 'sort' defined, but not used
WARNING: C:Program Filesadbmsstrg_engdone.py:82: Rule 'delete_db' defined, but not used
WARNING: C:Program Filesadbmsstrg_engdone.py:86: Rule 'delete_tb' defined, but not used
WARNING: C:Program Filesadbmsstrg_engdone.py:90: Rule 'delete_rec' defined, but not used
WARNING: C:Program Filesadbmsstrg_engdone.py:94: Rule 'delete_column' defined, but not used
WARNING: C:Program Filesadbmsstrg_engdone.py:98: Rule 'create_column' defined, but not used
WARNING: C:Program Filesadbmsstrg_engdone.py:102: Rule 'create_rec' defined, but not used
WARNING: C:Program Filesadbmsstrg_engdone.py:106: Rule 'display_tb' defined, but not used
WARNING: C:Program Filesadbmsstrg_engdone.py:110: Rule 'update_c' defined, but not used
WARNING: C:Program Filesadbmsstrg_engdone.py:114: Rule 'update_r' defined, but not used
WARNING: C:Program Filesadbmsstrg_engdone.py:118: Rule 'get_list' defined, but not used
WARNING: There are 14 unused rules
WARNING: Symbol 'change_tname' is unreachable
WARNING: Symbol 'create_db' is unreachable
WARNING: Symbol 'create_tb' is unreachable
WARNING: Symbol 'sort' is unreachable
WARNING: Symbol 'delete_db' is unreachable
WARNING: Symbol 'delete_tb' is unreachable
WARNING: Symbol 'delete_rec' is unreachable
WARNING: Symbol 'delete_column' is unreachable
WARNING: Symbol 'create_column' is unreachable
WARNING: Symbol 'create_rec' is unreachable
WARNING: Symbol 'display_tb' is unreachable
WARNING: Symbol 'update_c' is unreachable
WARNING: Symbol 'update_r' is unreachable
WARNING: Symbol 'get_list' is unreachable
FileLang> create_db test_tb
sly: Syntax error at line 1, token=CREATE_DB

Original code:

from sly import Lexer, Parser
from drm import *  # Import everything from the drm module

# Lexer
class FileLexer(Lexer):
    tokens = {CREATE_DB, CREATE_TB, CREATE_REC, CREATE_COLUMN,
              DELETE_DB, DELETE_TB, DELETE_REC, DELETE_COLUMN,
              CHANGE_DBNAME, CHANGE_TNAME, SORT, DISPLAY_TB,
              UPDATE_C, UPDATE_R, GET_LIST, COLUMN_NAME, VALUE,
              TYPE, MIN, MAX, CONSTRAINT, DBNAME, TNAME, NEWNAME}

    ignore = ' tn'

    CREATE_DB = r'create_db'
    CREATE_TB = r'create_tb'
    CREATE_REC = r'create_rec'
    CREATE_COLUMN = r'create_column'
    DELETE_DB = r'delete_db'
    DELETE_TB = r'delete_tb'
    DELETE_REC = r'delete_rec'
    DELETE_COLUMN = r'delete_column'
    CHANGE_DBNAME = r'change_dbname'
    CHANGE_TNAME = r'change_tname'
    SORT = r'sort'
    DISPLAY_TB = r'display_tb'
    UPDATE_C = r'update_c'
    UPDATE_R = r'update_r'
    GET_LIST = r'get_list'

    TYPE = r'(st|num)'
    MIN = r'[0-9]+'
    MAX = r'[0-9]+'
    CONSTRAINT = r'(NONE|NOTNONE|UNIQUE|NOUNI)'

    DBNAME = r'[a-zA-Z0-9_.-]+'
    TNAME = r'[a-zA-Z0-9_.-]+'
    NEWNAME = r'[a-zA-Z0-9_.-]+'
    COLUMN_NAME = r'[a-zA-Z_][a-zA-Z0-9_]*'
    VALUE = r'[a-zA-Z_0-9]+'

    @_(r'[0-9]+')
    def NUMBER(self, t):
        t.value = int(t.value)
        return t

    @_(r'".*?"')
    def TEXT(self, t):
        t.value = t.value
        return t

    def error(self, t):
        print(f'Illegal character {t.value[0]} at line {self.lineno}')
        self.index += 1

# Parser
class FileParser(Parser):
    tokens = FileLexer.tokens

    def __init__(self):
        self.symbol_table = {}

    @_('CHANGE_DBNAME DBNAME NEWNAME')
    def change_dbname(self, p):
        print(f'Change DB Name: {p.DBNAME} to {p.NEWNAME}')

    @_('CHANGE_TNAME DBNAME TNAME NEWNAME')
    def change_tname(self, p):
        print(f'Change Table Name: {p.DBNAME} {p.TNAME} to {p.NEWNAME}')

    @_('CREATE_DB DBNAME')
    def create_db(self, p):
        print(f'Create DB: {p.DBNAME}')

    @_('CREATE_TB DBNAME TNAME')
    def create_tb(self, p):
        print(f'Create Table: {p.DBNAME} {p.TNAME}')

    @_('SORT DBNAME TNAME')
    def sort(self, p):
        print(f'Sort: {p.DBNAME} {p.TNAME}')

    @_('DELETE_DB DBNAME')
    def delete_db(self, p):
        print(f'Delete DB: {p.DBNAME}')

    @_('DELETE_TB DBNAME TNAME')
    def delete_tb(self, p):
        print(f'Delete Table: {p.DBNAME} {p.TNAME}')

    @_('DELETE_REC DBNAME TNAME')
    def delete_rec(self, p):
        print(f'Delete Record: {p.DBNAME} {p.TNAME}')

    @_('DELETE_COLUMN DBNAME TNAME COLUMN_NAME')
    def delete_column(self, p):
        print(f'Delete Column: {p.DBNAME} {p.TNAME} {p.COLUMN_NAME}')

    @_('CREATE_COLUMN DBNAME TNAME COLUMN_NAME TYPE MIN MAX CONSTRAINT')
    def create_column(self, p):
        print(f'Create Column: {p.DBNAME} {p.TNAME} {p.COLUMN_NAME} {p.TYPE} {p.MIN} {p.MAX} {p.CONSTRAINT}')

    @_('CREATE_REC DBNAME TNAME')
    def create_rec(self, p):
        print(f'Create Record: {p.DBNAME} {p.TNAME}')

    @_('DISPLAY_TB DBNAME TNAME')
    def display_tb(self, p):
        print(f'Display Table: {p.DBNAME} {p.TNAME}')

    @_('UPDATE_C DBNAME TNAME COLUMN_NAME VALUE')
    def update_c(self, p):
        print(f'Update Column: {p.DBNAME} {p.TNAME} {p.COLUMN_NAME} {p.VALUE}')

    @_('UPDATE_R DBNAME TNAME COLUMN_NAME VALUE')
    def update_r(self, p):
        print(f'Update Record: {p.DBNAME} {p.TNAME} {p.COLUMN_NAME} {p.VALUE}')

    @_('GET_LIST DBNAME TNAME COLUMN_NAME')
    def get_list(self, p):
        print(f'Get List: {p.DBNAME} {p.TNAME} {p.COLUMN_NAME}')

# Example usage
if __name__ == '__main__':
    lexer = FileLexer()
    parser = FileParser()

    while True:
        try:
            text = input('FileLang> ')
            tokens = lexer.tokenize(text)
            parser.parse(tokens)
        except EOFError:
            break