इनपुट बफरिंग (Input Buffering in Compiler Design)

कंपाइलर का पहला चरण, Lexical Analysis, सोर्स कोड को character-by-character पढ़ता है। लेकिन बड़े प्रोग्राम्स में यह प्रक्रिया बहुत धीमी हो सकती है। इसी समस्या को हल करने के लिए Input Buffering तकनीक का उपयोग किया जाता है। यह तकनीक characters को कुशलतापूर्वक पढ़ने और स्कैन करने के लिए दो buffers का प्रयोग करती है।

📘 इनपुट बफरिंग क्या है?

Input Buffering एक तकनीक है जो Lexical Analyzer को तेज़ी से characters पढ़ने में मदद करती है। यह सोर्स प्रोग्राम को एक बार में छोटे हिस्सों (chunks) में memory में लोड करती है। इससे character stream को manage करना आसान हो जाता है और बार-बार I/O operations करने की आवश्यकता नहीं होती।

🧠 उदाहरण:

मान लीजिए किसी प्रोग्राम में 1 लाख characters हैं। अगर प्रत्येक character को अलग-अलग पढ़ा जाए, तो बहुत समय लगेगा। Input Buffering इस समस्या को हल करता है — यह एक समय में 4096 (या अधिक) characters को एक buffer में लोड कर देता है।

⚙️ इनपुट बफरिंग की आवश्यकता क्यों?

• 🔹 Lexical Analyzer character-by-character scanning करता है।
• 🔹 बार-बार I/O operation करना महंगा (expensive) होता है।
• 🔹 Large programs को कुशलतापूर्वक पढ़ने के लिए double buffering आवश्यक है।

🧩 डबल बफरिंग तकनीक (Double Buffering Technique)

Input Buffering में दो buffers का उपयोग किया जाता है, प्रत्येक buffer का size समान होता है। जब पहला buffer पढ़ा जाता है, तो दूसरा buffer अगला डेटा लोड करता है। इससे I/O delay समाप्त हो जाता है और Lexical Analyzer लगातार characters पढ़ सकता है।

📊 संरचना (Structure):

|----------Buffer 1----------|----------Buffer 2----------|
| a | b | c | d | e | EOF1 | x | y | z | w | k | EOF2 |
^
Pointer (forward)

🧩 विशेष बिंदु:

• Buffer 1 और Buffer 2 के बीच कोई गैप नहीं होता।
• प्रत्येक buffer के अंत में एक Sentinel Character (EOF) रखा जाता है।
• जब एक buffer समाप्त हो जाता है, pointer अपने आप दूसरे buffer पर चला जाता है।

📗 बफरिंग प्रक्रिया के चरण:

1. Step 1: Source code को Buffer 1 में लोड करें।
2. Step 2: Characters को read करें जब तक EOF1 नहीं आता।
3. Step 3: Buffer 1 समाप्त होने पर Buffer 2 को लोड करें।
4. Step 4: Forward pointer दोनों buffers के बीच स्विच करता रहता है।

🧮 Forward और Lexeme Pointer:

Lexical Analyzer दो pointers का उपयोग करता है —

• Lexeme Begin Pointer: वर्तमान lexeme की शुरुआत को इंगित करता है।
• Forward Pointer: अगले character को इंगित करता है।

उदाहरण:

Source: sum = total + 20;
Pointers:
Lexeme Begin → s
Forward → u (Moves forward until token completed)

📊 Algorithm of Double Buffering:

1. Load first buffer with input characters.
2. Set forward = begin.
3. Repeat until EOF:
      a. If forward = EOF of current buffer:
             Load next buffer.
      b. Read next character.
      c. If token complete:
             Process lexeme and reset begin pointer.

⚡ फायदे (Advantages):

• ✅ Fast and continuous character scanning।
• ✅ Reduced disk I/O operations।
• ✅ Improved compiler performance।
• ✅ Efficient token recognition।

⚠️ सीमाएँ (Limitations):

• ❌ Implementation complexity बढ़ जाती है।
• ❌ Memory requirement थोड़ी अधिक होती है।

🚀 आधुनिक उपयोग (2025 में):

• 🔹 Parallel Buffering in multi-threaded compilers।
• 🔹 AI-driven Input Prediction।
• 🔹 Dynamic Buffer Size Adjustment for large source files।

📙 निष्कर्ष:

Input Buffering Lexical Analyzer की गति और कार्यक्षमता को कई गुना बढ़ा देता है। यह Double Buffering Technique के माध्यम से characters को तेजी से पढ़ता है और seamless token generation सुनिश्चित करता है। 2025 में, आधुनिक AI-सक्षम कंपाइलर इस तकनीक को और अधिक उन्नत रूप में अपना रहे हैं।