Herkese selamlar TurkHackTeam ailesi,
Bugün serimize kaldığımız yerden devam ediyoruz. Bu konumuzda dilimize değişken tanımlama, yazdır fonksiyonu oluşturma (print) ve kullanıcıdan girdi alma (input) ekleyeceğiz. Şimdiden iyi okumalar.
NOT: Bu konu sadece eğitim amaçlıdır. Herhangi bir programlama dili geliştirip piyasaya sürmek söz konusu değildir.
Şimdi buradaki dosyalarımızı tek tek güncelleyeceğiz. Ben kodları komple vereceğim direkt kullanmak isterseniz kopyala yapıştır yapabilirsiniz:
Şimdi dosyalarımızı güncelleyelim. İlk olarak ep_console.py:
interpreter.py:
lexer.py:
Son olarak parser.py:
Tüm dosyalarımız güncellendi. Şimdi ep_console.py dosyamızı çalıştıralım ve help komutunu yazalım:
Şimdi gelin ilk önce değişken tanımlayalım sonrasında ekrana yazdıralım:
Gördüğünüz gibi artık değişken tanımlayıp ekrana yazdırabiliyoruz. Şimdi kullanıcıdan bir girdi alalım:
Artık kullanıcıdan girdi alabiliyoruz. Programlama dilimiz adım adım karmaşık işlemleri yapmaya başladı bile. İşte Python ile bunu yapmak çok kolay. Ne karmaşık modüller var ne de karmaşık kod satırları. Hepsi temelde bildiğiniz kodlar
Konumuzun sonuna geldik. Bir sonraki konuda görüşmek üzere kendinize iyi bakın
Bugün serimize kaldığımız yerden devam ediyoruz. Bu konumuzda dilimize değişken tanımlama, yazdır fonksiyonu oluşturma (print) ve kullanıcıdan girdi alma (input) ekleyeceğiz. Şimdiden iyi okumalar.
NOT: Bu konu sadece eğitim amaçlıdır. Herhangi bir programlama dili geliştirip piyasaya sürmek söz konusu değildir.
Şimdi buradaki dosyalarımızı tek tek güncelleyeceğiz. Ben kodları komple vereceğim direkt kullanmak isterseniz kopyala yapıştır yapabilirsiniz:
Şimdi dosyalarımızı güncelleyelim. İlk olarak ep_console.py:
Python:
import tkinter as tk
from lexer import Lexer
from parser import Parser
from interpreter import Interpreter
class THTShell:
def __init__(self, root):
self.root = root
self.root.title("THTShell — Command Console")
self.root.geometry("900x550")
self.root.configure(bg="black")
self.text_area = tk.Text(
root,
bg="black",
fg="white",
insertbackground="white",
font=("Consolas", 12),
borderwidth=0,
highlightthickness=0
)
self.text_area.pack(fill="both", expand=True)
self.text_area.bind("<Return>", self.handle_enter)
self.text_area.bind("<Key>", self.on_keypress)
self.text_area.focus()
self.cmd_prefix = "C:\\THTShell>"
self.last_prompt_index = None
self.waiting_input = False
self.input_callback = None
self.interpreter = Interpreter(self)
self.insert_text("TurkHackTeam THTShell [Version 1.1.0]")
self.insert_text("(c) TurkHackTeam Corporation. All rights reserved.\n")
self.insert_prompt()
def insert_text(self, text, color="white", newline=True):
self.text_area.tag_config(color, foreground=color)
if newline:
self.text_area.insert(tk.END, text + "\n", color)
else:
self.text_area.insert(tk.END, text, color)
self.text_area.see(tk.END)
def insert_prompt(self):
self.text_area.insert(tk.END, f"{self.cmd_prefix} ", "white")
self.text_area.see(tk.END)
self.last_prompt_index = self.text_area.index(f"end-{len(self.cmd_prefix) + 2}c")
def on_keypress(self, event):
if not self.last_prompt_index:
return
try:
if self.text_area.compare(tk.INSERT, "<", self.last_prompt_index):
self.text_area.mark_set("insert", tk.END)
except tk.TclError:
return "break"
if event.keysym == "BackSpace":
try:
if self.text_area.compare(tk.INSERT, "<=", self.last_prompt_index):
return "break"
except tk.TclError:
return "break"
def handle_enter(self, event):
cursor_pos = self.text_area.index("end-1c")
line = self.text_area.get(self.last_prompt_index, cursor_pos).strip()
self.text_area.insert(tk.END, "\n")
if self.waiting_input and self.input_callback:
self.waiting_input = False
callback = self.input_callback
self.input_callback = None
callback(line)
return "break"
command = line.replace(self.cmd_prefix, "").strip()
if command.lower() in ["exit", "quit"]:
self.insert_text("Çıkış yapılıyor...", "yellow")
self.root.after(1000, self.root.destroy)
return "break"
if command == "":
self.insert_prompt()
return "break"
if command.lower() == "cls":
self.text_area.delete("1.0", tk.END)
self.insert_text("TurkHackTeam THTShell [Version 1.1.0]")
self.insert_text("(c) TurkHackTeam Corporation. All rights reserved.\n")
self.insert_prompt()
return "break"
if command.lower() in ["help", "?"]:
self.show_help()
self.insert_prompt()
return "break"
result = self.run_command(command)
if not self.waiting_input:
if result is not None and result != "":
self.insert_text(str(result), "lime")
self.insert_prompt()
return "break"
def show_help(self):
help_text = """
THTShell Komutları:
help / ? - Komut listesini gösterir
cls - Ekranı temizler
exit / quit - Shell'den çıkar
yazdır() - Ekrana çıktı verir
girdi() - Kullanıcıdan veri alır
"""
self.insert_text(help_text, "cyan")
def run_command(self, command):
try:
lexer = Lexer(command)
tokens = lexer.generate_tokens()
parser = Parser(tokens)
tree = parser.parse()
result = self.interpreter.visit(tree)
return result
except Exception as e:
self.insert_text(f"Hata: {e}", "red")
return None
def ask_input(self, prompt, callback):
self.insert_text(prompt, "yellow", newline=False)
self.text_area.insert(tk.END, " ", "white")
self.text_area.see(tk.END)
self.waiting_input = True
self.input_callback = callback
self.last_prompt_index = self.text_area.index("end-1c")
if __name__ == "__main__":
root = tk.Tk()
app = THTShell(root)
root.mainloop()interpreter.py:
Python:
from parser import NumberNode, StringNode, VarAccessNode, AssignNode, BinOpNode, FuncCallNode
import re
class Interpreter:
def __init__(self, shell=None):
self.variables = {}
self.shell = shell
def visit(self, node):
if isinstance(node, NumberNode):
return node.value
elif isinstance(node, StringNode):
return node.value
elif isinstance(node, BinOpNode):
return self.visit_BinOpNode(node)
elif isinstance(node, AssignNode):
return self.visit_AssignNode(node)
elif isinstance(node, VarAccessNode):
return self.visit_VarAccessNode(node)
elif isinstance(node, FuncCallNode):
return self.visit_FuncCallNode(node)
else:
raise Exception(f"Bilinmeyen düğüm tipi: {type(node)}")
def visit_BinOpNode(self, node):
left = self.visit(node.left)
right = self.visit(node.right)
if node.op.type == "PLUS":
return f"{left} {right}" if isinstance(left, str) or isinstance(right, str) else left + right
elif node.op.type == "MINUS":
return left - right
elif node.op.type == "MUL":
return left * right
elif node.op.type == "DIV":
return left / right
def visit_AssignNode(self, node):
value = self.visit(node.value_node)
self.variables[node.var_name] = value
return f"{node.var_name} = {value}"
def visit_VarAccessNode(self, node):
if node.var_name in self.variables:
return self.variables[node.var_name]
raise Exception(f"'{node.var_name}' tanımlı değil.")
def visit_FuncCallNode(self, node):
func_name = node.func_name
arg_value = self.visit(node.arg_node) if node.arg_node else ""
if func_name == "yazdır":
output = str(arg_value)
if self.shell:
self.shell.insert_text(output, "lime")
else:
print(output)
return ""
elif func_name == "girdi":
prompt = str(arg_value)
if self.shell:
self.shell.insert_text(f"{prompt} ", "yellow", newline=False)
self.shell.text_area.see("end")
self.shell.waiting_input = True
def on_input(value):
self.shell.insert_text(value, "white")
self.variables["_"] = value
self.shell.waiting_input = False
self.shell.insert_prompt()
self.shell.input_callback = on_input
self.shell.last_prompt_index = self.shell.text_area.index("end-1c")
return ""
else:
return input(prompt + " ")
else:
raise Exception(f"Bilinmeyen fonksiyon: {func_name}")lexer.py:
Python:
# lexer.py
class Token:
def __init__(self, type_, value=None):
self.type = type_
self.value = value
def __repr__(self):
return f"{self.type}:{self.value}" if self.value is not None else f"{self.type}"
class Lexer:
def __init__(self, text):
self.text = text
self.pos = 0
self.current_char = self.text[self.pos] if self.text else None
def advance(self):
"""Bir sonraki karaktere geç"""
self.pos += 1
self.current_char = self.text[self.pos] if self.pos < len(self.text) else None
def generate_tokens(self):
"""Metni tokenlara dönüştürür"""
tokens = []
while self.current_char is not None:
ch = self.current_char
if ch.isspace():
self.advance()
elif ch.isdigit():
tokens.append(self.make_number())
elif ch.isalpha() or ch == "_":
tokens.append(self.make_identifier())
elif ch in ['"', "'"]:
tokens.append(self.make_string())
elif ch == '+':
tokens.append(Token("PLUS"))
self.advance()
elif ch == '-':
tokens.append(Token("MINUS"))
self.advance()
elif ch == '*':
tokens.append(Token("MUL"))
self.advance()
elif ch == '/':
tokens.append(Token("DIV"))
self.advance()
elif ch == '=':
tokens.append(Token("EQUALS"))
self.advance()
elif ch == '(':
tokens.append(Token("LPAREN"))
self.advance()
elif ch == ')':
tokens.append(Token("RPAREN"))
self.advance()
else:
print(f"[Uyarı] Bilinmeyen karakter atlandı: {repr(ch)}")
self.advance()
return tokens
def make_number(self):
num = ""
while self.current_char is not None and self.current_char.isdigit():
num += self.current_char
self.advance()
return Token("NUMBER", int(num))
def make_identifier(self):
ident = ""
while self.current_char is not None and (self.current_char.isalnum() or self.current_char == "_"):
ident += self.current_char
self.advance()
return Token("IDENTIFIER", ident)
def make_string(self):
quote = self.current_char
self.advance()
result = ""
while self.current_char is not None and self.current_char != quote:
result += self.current_char
self.advance()
if self.current_char != quote:
raise Exception("Tırnak kapanmadı.")
self.advance()
return Token("STRING", result)Son olarak parser.py:
Python:
from lexer import Token
class NumberNode:
def __init__(self, value):
self.value = value
def __repr__(self):
return f"{self.value}"
class StringNode:
def __init__(self, value):
self.value = value
def __repr__(self):
return f"\"{self.value}\""
class VarAccessNode:
def __init__(self, var_name):
self.var_name = var_name
def __repr__(self):
return f"{self.var_name}"
class AssignNode:
def __init__(self, var_name, value_node):
self.var_name = var_name
self.value_node = value_node
def __repr__(self):
return f"({self.var_name} = {self.value_node})"
class BinOpNode:
def __init__(self, left, op, right):
self.left = left
self.op = op
self.right = right
def __repr__(self):
return f"({self.left} {self.op.type} {self.right})"
class FuncCallNode:
def __init__(self, func_name, arg_node):
self.func_name = func_name
self.arg_node = arg_node
def __repr__(self):
return f"{self.func_name}({self.arg_node})"
class Parser:
def __init__(self, tokens):
self.tokens = tokens
self.pos = 0
self.current_token = self.tokens[self.pos] if self.tokens else None
def advance(self):
self.pos += 1
self.current_token = self.tokens[self.pos] if self.pos < len(self.tokens) else None
def parse(self):
if not self.current_token:
return None
return self.expr()
def expr(self):
node = self.term()
while self.current_token is not None and self.current_token.type in ("PLUS", "MINUS"):
op = self.current_token
self.advance()
right = self.term()
node = BinOpNode(node, op, right)
return node
def term(self):
node = self.factor()
while self.current_token is not None and self.current_token.type in ("MUL", "DIV"):
op = self.current_token
self.advance()
right = self.factor()
node = BinOpNode(node, op, right)
return node
def factor(self):
token = self.current_token
if token is None:
raise Exception("Beklenmeyen dosya sonu")
if token.type == "NUMBER":
self.advance()
return NumberNode(token.value)
elif token.type == "STRING":
self.advance()
return StringNode(token.value)
elif token.type == "LPAREN":
self.advance()
expr = self.expr()
if not self.current_token or self.current_token.type != "RPAREN":
raise Exception("Beklenen ')' eksik")
self.advance()
return expr
elif token.type == "IDENTIFIER":
var_name = token.value
self.advance()
if self.current_token and self.current_token.type == "LPAREN":
self.advance()
arg_node = None
if self.current_token and self.current_token.type != "RPAREN":
arg_node = self.expr()
if not self.current_token or self.current_token.type != "RPAREN":
raise Exception("Beklenen ')' eksik")
self.advance()
return FuncCallNode(var_name, arg_node)
elif self.current_token and self.current_token.type == "EQUALS":
self.advance()
value_node = self.expr()
return AssignNode(var_name, value_node)
else:
return VarAccessNode(var_name)
raise Exception(f"Beklenmeyen token: {token}")Tüm dosyalarımız güncellendi. Şimdi ep_console.py dosyamızı çalıştıralım ve help komutunu yazalım:
Şimdi gelin ilk önce değişken tanımlayalım sonrasında ekrana yazdıralım:
Gördüğünüz gibi artık değişken tanımlayıp ekrana yazdırabiliyoruz. Şimdi kullanıcıdan bir girdi alalım:
Artık kullanıcıdan girdi alabiliyoruz. Programlama dilimiz adım adım karmaşık işlemleri yapmaya başladı bile. İşte Python ile bunu yapmak çok kolay. Ne karmaşık modüller var ne de karmaşık kod satırları. Hepsi temelde bildiğiniz kodlar
Konumuzun sonuna geldik. Bir sonraki konuda görüşmek üzere kendinize iyi bakın
