%{
/* Código C de configuração */
%}

/* Definições */
DIGITO [0-9]
ID [a-zA-Z][a-zA-Z0-9_]*

%%
/* Regras */
{DIGITO}+ { return NUM; }
{ID} { return ID; }
"+" { return MAIS; }
%%

/* Código auxiliar */
int main() {
 yylex();
 return 0;
}

import ply.lex as lex

# Lista de tokens
tokens = ('NUMBER', 'ID')

# Regras
def t_NUMBER(t):
 r'\d+'
 t.value = int(t.value)
 return t

def t_ID(t):
 r'[a-zA-Z][a-zA-Z0-9_]*'
 return t

# Ignorar espaços
t_ignore = ' \t\n'

# Tratamento de erros
def t_error(t):
 print(f"Caractere ilegal: {t.value[0]}")
 t.lexer.skip(1)

# Construir lexer
lexer = lex.lex()

# Implementação simples em Python
class SymbolTable:
 def __init__(self):
 self.symbols = {}
 
 def insert(self, name, type=None):
 if name not in self.symbols:
 self.symbols[name] = {
 'type': type,
 'line': [],
 'used': False
 }
 
 def lookup(self, name):
 return name in self.symbols
 
 def get_info(self, name):
 if self.lookup(name):
 return self.symbols[name]
 return None

# String com aspas duplas
def t_STRING(t):
 r'"([^"\\]|\\.)*"'
 # Remove as aspas
 t.value = t.value[1:-1]
 # Processa sequências de escape
 t.value = t.value.replace('\\n', '\n')
 t.value = t.value.replace('\\t', '\t')
 t.value = t.value.replace('\\"', '"')
 return t

# Erro para string não fechada
def t_error_string(t):
 r'"([^"\\]|\\.)*\n'
 print(f"String não fechada na linha {t.lexer.lineno}")
 t.lexer.skip(len(t.value))

def t_NUMBER(t):
 r'0x[0-9a-fA-F]+|0b[01]+|0o[0-7]+|\d+(\.\d+)?'
 # Hexadecimal
 if t.value.startswith('0x'):
 t.value = int(t.value[2:], 16)
 # Binário
 elif t.value.startswith('0b'):
 t.value = int(t.value[2:], 2)
 # Octal
 elif t.value.startswith('0o'):
 t.value = int(t.value[2:], 8)
 # Ponto flutuante
 elif '.' in t.value:
 t.value = float(t.value)
 # Decimal
 else:
 t.value = int(t.value)
 return t

# Exemplo simples de avaliador de expressões
def evaluate_expression(expr_str):
 # Inicializar o lexer
 lexer = lex.lex()
 lexer.input(expr_str)
 
 # Obter tokens
 tokens = []
 for tok in lexer:
 tokens.append(tok)
 
 # Analisar e avaliar...
 result = parse_and_evaluate(tokens)
 return result

# Uso em um programa maior
user_input = input("Digite uma expressão: ")
try:
 result = evaluate_expression(user_input)
 print(f"Resultado: {result}")
except Exception as e:
 print(f"Erro na expressão: {e}")