ಕಂಪೈಲರ್ ಡಿಸೈನ್: ಲೆಕ್ಸಿಕಲ್ ಅನಾಲಿಸಿಸ್ ಮೂಲಭೂತ ಅಂಶಗಳು

ಕಂಪೈಲರ್ ಡಿಸೈನ್ ಎಂಬುದು ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನದ ಒಂದು ಆಕರ್ಷಕ ಮತ್ತು ನಿರ್ಣಾಯಕ ಕ್ಷೇತ್ರವಾಗಿದ್ದು, ಇದು ಆಧುನಿಕ ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿಯ ಹೆಚ್ಚಿನ ಭಾಗಕ್ಕೆ ಆಧಾರವಾಗಿದೆ. ಕಂಪೈಲರ್ ಮಾನವ-ಓದಬಲ್ಲ ಸೋರ್ಸ್ ಕೋಡ್ ಮತ್ತು ಯಂತ್ರ-ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಸೂಚನೆಗಳ ನಡುವಿನ ಸೇತುವೆಯಾಗಿದೆ. ಈ ಲೇಖನವು ಸಂಕಲನ ಪ್ರಕ್ರಿಯೆಯ ಆರಂಭಿಕ ಹಂತವಾದ ಲೆಕ್ಸಿಕಲ್ ಅನಾಲಿಸಿಸ್‌ನ ಮೂಲಭೂತ ಅಂಶಗಳನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ. ನಾವು ಅದರ ಉದ್ದೇಶ, ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಗಳು ಮತ್ತು ವಿಶ್ವಾದ್ಯಂತ ಮಹತ್ವಾಕಾಂಕ್ಷಿ ಕಂಪೈಲರ್ ವಿನ್ಯಾಸಕರು ಮತ್ತು ಸಾಫ್ಟ್‌ವೇರ್ ಇಂಜಿನಿಯರ್‌ಗಳಿಗೆ ಪ್ರಾಯೋಗಿಕ ಪರಿಣಾಮಗಳನ್ನು ಅನ್ವೇಷಿಸುತ್ತೇವೆ.

ಲೆಕ್ಸಿಕಲ್ ಅನಾಲಿಸಿಸ್ ಎಂದರೇನು?

ಲೆಕ್ಸಿಕಲ್ ಅನಾಲಿಸಿಸ್, ಸ್ಕ್ಯಾನಿಂಗ್ ಅಥವಾ ಟೋಕನೈಸಿಂಗ್ ಎಂದೂ ಕರೆಯಲ್ಪಡುತ್ತದೆ, ಇದು ಕಂಪೈಲರ್‌ನ ಮೊದಲ ಹಂತವಾಗಿದೆ. ಇದರ ಪ್ರಾಥಮಿಕ ಕಾರ್ಯವೆಂದರೆ ಸೋರ್ಸ್ ಕೋಡ್ ಅನ್ನು ಅಕ್ಷರಗಳ ಸ್ಟ್ರೀಮ್ ಆಗಿ ಓದುವುದು ಮತ್ತು ಅವುಗಳನ್ನು ಲೆಕ್ಸೀಮ್‌ಗಳು ಎಂಬ ಅರ್ಥಪೂರ್ಣ ಅನುಕ್ರಮಗಳಾಗಿ ಗುಂಪು ಮಾಡುವುದು. ನಂತರ ಪ್ರತಿಯೊಂದು ಲೆಕ್ಸೀಮ್ ಅನ್ನು ಅದರ ಪಾತ್ರದ ಆಧಾರದ ಮೇಲೆ ವರ್ಗೀಕರಿಸಲಾಗುತ್ತದೆ, ಇದರ ಪರಿಣಾಮವಾಗಿ ಟೋಕನ್‌ಗಳ ಅನುಕ್ರಮವು ಉಂಟಾಗುತ್ತದೆ. ಇದನ್ನು ಆರಂಭಿಕ ವಿಂಗಡಣೆ ಮತ್ತು ಲೇಬಲಿಂಗ್ ಪ್ರಕ್ರಿಯೆ ಎಂದು ಯೋಚಿಸಿ, ಇದು ಮುಂದಿನ ಪ್ರಕ್ರಿಯೆಗೆ ಇನ್‌ಪುಟ್ ಅನ್ನು ಸಿದ್ಧಪಡಿಸುತ್ತದೆ.

ನೀವು `x = y + 5;` ಎಂಬ ವಾಕ್ಯವನ್ನು ಹೊಂದಿದ್ದೀರಿ ಎಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. ಲೆಕ್ಸಿಕಲ್ ಅನಾಲೈಸರ್ ಇದನ್ನು ಈ ಕೆಳಗಿನ ಟೋಕನ್‌ಗಳಾಗಿ ವಿಭಜಿಸುತ್ತದೆ:

• ಐಡೆಂಟಿಫೈಯರ್: `x`
• ಅಸೈನ್‌ಮೆಂಟ್ ಆಪರೇಟರ್: `=`
• ಐಡೆಂಟಿಫೈಯರ್: `y`
• ಸಂಕಲನ ಆಪರೇಟರ್: `+`
• ಇಂಟಿಜರ್ ಲಿಟರಲ್: `5`
• ಸೆಮಿಕೋಲನ್: `;`

ಲೆಕ್ಸಿಕಲ್ ಅನಾಲೈಸರ್ ಮೂಲಭೂತವಾಗಿ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯ ಈ ಮೂಲಭೂತ ಬಿಲ್ಡಿಂಗ್ ಬ್ಲಾಕ್‌ಗಳನ್ನು ಗುರುತಿಸುತ್ತದೆ.

ಲೆಕ್ಸಿಕಲ್ ಅನಾಲಿಸಿಸ್‌ನಲ್ಲಿನ ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಗಳು

ಟೋಕನ್‌ಗಳು ಮತ್ತು ಲೆಕ್ಸೀಮ್‌ಗಳು

ಮೇಲೆ ಹೇಳಿದಂತೆ, ಟೋಕನ್ ಎನ್ನುವುದು ಲೆಕ್ಸೀಮ್‌ನ ವರ್ಗೀಕರಿಸಿದ ಪ್ರಾತಿನಿಧ್ಯವಾಗಿದೆ. ಲೆಕ್ಸೀಮ್ ಎನ್ನುವುದು ಸೋರ್ಸ್ ಕೋಡ್‌ನಲ್ಲಿನ ಅಕ್ಷರಗಳ ನಿಜವಾದ ಅನುಕ್ರಮವಾಗಿದ್ದು, ಅದು ಟೋಕನ್‌ಗಾಗಿ ಒಂದು ಪ್ಯಾಟರ್ನ್‌ಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ. ಪೈಥಾನ್‌ನಲ್ಲಿನ ಈ ಕೆಳಗಿನ ಕೋಡ್ ತುಣುಕನ್ನು ಪರಿಗಣಿಸಿ:

            if x > 5:
    print("x is greater than 5")
            

              
                Copy
              
            
          

ಈ ತುಣುಕಿನಿಂದ ಕೆಲವು ಟೋಕನ್‌ಗಳು ಮತ್ತು ಲೆಕ್ಸೀಮ್‌ಗಳ ಉದಾಹರಣೆಗಳು ಇಲ್ಲಿವೆ:

• ಟೋಕನ್: KEYWORD, ಲೆಕ್ಸೀಮ್: `if`
• ಟೋಕನ್: IDENTIFIER, ಲೆಕ್ಸೀಮ್: `x`
• ಟೋಕನ್: RELATIONAL_OPERATOR, ಲೆಕ್ಸೀಮ್: `>`
• ಟೋಕನ್: INTEGER_LITERAL, ಲೆಕ್ಸೀಮ್: `5`
• ಟೋಕನ್: COLON, ಲೆಕ್ಸೀಮ್: `:`
• ಟೋಕನ್: KEYWORD, ಲೆಕ್ಸೀಮ್: `print`
• ಟೋಕನ್: STRING_LITERAL, ಲೆಕ್ಸೀಮ್: `"x is greater than 5"`

ಟೋಕನ್ ಲೆಕ್ಸೀಮ್‌ನ *ವರ್ಗವನ್ನು* ಪ್ರತಿನಿಧಿಸುತ್ತದೆ, ಆದರೆ ಲೆಕ್ಸೀಮ್ ಸೋರ್ಸ್ ಕೋಡ್‌ನಿಂದ *ನಿಜವಾದ ಸ್ಟ್ರಿಂಗ್* ಆಗಿದೆ. ಪಾರ್ಸರ್, ಸಂಕಲನದ ಮುಂದಿನ ಹಂತ, ಪ್ರೋಗ್ರಾಂನ ರಚನೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಟೋಕನ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ.

ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳು

ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳು (regex) ಅಕ್ಷರಗಳ ಮಾದರಿಗಳನ್ನು ವಿವರಿಸಲು ಒಂದು ಶಕ್ತಿಯುತ ಮತ್ತು ಸಂಕ್ಷಿಪ್ತ ಸಂಕೇತವಾಗಿದೆ. ಲೆಕ್ಸಿಕಲ್ ಅನಾಲಿಸಿಸ್‌ನಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ಟೋಕನ್‌ಗಳಾಗಿ ಗುರುತಿಸಲು ಲೆಕ್ಸೀಮ್‌ಗಳು ಹೊಂದಿಕೆಯಾಗಬೇಕಾದ ಮಾದರಿಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಇವುಗಳನ್ನು ವ್ಯಾಪಕವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳು ಕೇವಲ ಕಂಪೈಲರ್ ವಿನ್ಯಾಸದಲ್ಲಿ ಮಾತ್ರವಲ್ಲದೆ ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನದ ಅನೇಕ ಕ್ಷೇತ್ರಗಳಲ್ಲಿ, ಪಠ್ಯ ಸಂಸ್ಕರಣೆಯಿಂದ ಹಿಡಿದು ನೆಟ್‌ವರ್ಕ್ ಭದ್ರತೆಯವರೆಗೆ ಒಂದು ಮೂಲಭೂತ ಪರಿಕಲ್ಪನೆಯಾಗಿದೆ.

ಕೆಲವು ಸಾಮಾನ್ಯ ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್ ಚಿಹ್ನೆಗಳು ಮತ್ತು ಅವುಗಳ ಅರ್ಥಗಳು ಇಲ್ಲಿವೆ:

• `.` (ಡಾಟ್): ಹೊಸ ಸಾಲನ್ನು ಹೊರತುಪಡಿಸಿ ಯಾವುದೇ ಒಂದೇ ಅಕ್ಷರಕ್ಕೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ.
• `*` (ಆಸ್ಟರಿಸ್ಕ್): ಹಿಂದಿನ ಅಂಶವನ್ನು ಶೂನ್ಯ ಅಥವಾ ಹೆಚ್ಚಿನ ಬಾರಿ ಹೊಂದಿಸುತ್ತದೆ.
• `+` (ಪ್ಲಸ್): ಹಿಂದಿನ ಅಂಶವನ್ನು ಒಂದು ಅಥವಾ ಹೆಚ್ಚಿನ ಬಾರಿ ಹೊಂದಿಸುತ್ತದೆ.
• `?` (ಪ್ರಶ್ನಾರ್ಥಕ ಚಿಹ್ನೆ): ಹಿಂದಿನ ಅಂಶವನ್ನು ಶೂನ್ಯ ಅಥವಾ ಒಂದು ಬಾರಿ ಹೊಂದಿಸುತ್ತದೆ.
• `[]` (ಚೌಕ ಆವರಣಗಳು): ಅಕ್ಷರ ವರ್ಗವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, `[a-z]` ಯಾವುದೇ ಸಣ್ಣಕ್ಷರಕ್ಕೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ.
• `[^]` (ನಿರಾಕರಿಸಿದ ಚೌಕ ಆವರಣಗಳು): ನಿರಾಕರಿಸಿದ ಅಕ್ಷರ ವರ್ಗವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, `[^0-9]` ಅಂಕಿಯಲ್ಲದ ಯಾವುದೇ ಅಕ್ಷರಕ್ಕೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ.
• `|` (ಪೈಪ್): ಪರ್ಯಾಯವನ್ನು (OR) ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, `a|b` `a` ಅಥವಾ `b` ಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ.
• `()` (ಪ್ಯಾರೆಂಥೆಸಿಸ್): ಅಂಶಗಳನ್ನು ಒಟ್ಟಿಗೆ ಗುಂಪು ಮಾಡುತ್ತದೆ ಮತ್ತು ಅವುಗಳನ್ನು ಸೆರೆಹಿಡಿಯುತ್ತದೆ.
• `\` (ಬ್ಯಾಕ್‌ಸ್ಲ್ಯಾಶ್): ವಿಶೇಷ ಅಕ್ಷರಗಳನ್ನು ತಪ್ಪಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, `\.` ಅಕ್ಷರಶಃ ಡಾಟ್‌ಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ.

ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳನ್ನು ಟೋಕನ್‌ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಹೇಗೆ ಬಳಸಬಹುದು ಎಂಬುದರ ಕೆಲವು ಉದಾಹರಣೆಗಳನ್ನು ನೋಡೋಣ:

• ಇಂಟಿಜರ್ ಲಿಟರಲ್: `[0-9]+` (ಒಂದು ಅಥವಾ ಹೆಚ್ಚಿನ ಅಂಕೆಗಳು)
• ಐಡೆಂಟಿಫೈಯರ್: `[a-zA-Z_][a-zA-Z0-9_]*` (ಅಕ್ಷರ ಅಥವಾ ಅಂಡರ್‌ಸ್ಕೋರ್‌ನಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ, ನಂತರ ಶೂನ್ಯ ಅಥವಾ ಹೆಚ್ಚಿನ ಅಕ್ಷರಗಳು, ಅಂಕೆಗಳು ಅಥವಾ ಅಂಡರ್‌ಸ್ಕೋರ್‌ಗಳು)
• ಫ್ಲೋಟಿಂಗ್-ಪಾಯಿಂಟ್ ಲಿಟರಲ್: `[0-9]+\.[0-9]+` (ಒಂದು ಅಥವಾ ಹೆಚ್ಚಿನ ಅಂಕೆಗಳು, ನಂತರ ಒಂದು ಡಾಟ್, ನಂತರ ಒಂದು ಅಥವಾ ಹೆಚ್ಚಿನ ಅಂಕೆಗಳು) ಇದು ಒಂದು ಸರಳೀಕೃತ ಉದಾಹರಣೆ; ಹೆಚ್ಚು ದೃಢವಾದ ರೆಜೆಕ್ಸ್ ಘಾತಾಂಕಗಳು ಮತ್ತು ಐಚ್ಛಿಕ ಚಿಹ್ನೆಗಳನ್ನು ನಿಭಾಯಿಸುತ್ತದೆ.

ವಿವಿಧ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳು ಐಡೆಂಟಿಫೈಯರ್‌ಗಳು, ಇಂಟಿಜರ್ ಲಿಟರಲ್‌ಗಳು ಮತ್ತು ಇತರ ಟೋಕನ್‌ಗಳಿಗೆ ವಿಭಿನ್ನ ನಿಯಮಗಳನ್ನು ಹೊಂದಿರಬಹುದು. ಆದ್ದರಿಂದ, ಅನುಗುಣವಾದ ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳನ್ನು ಅದಕ್ಕೆ ಅನುಗುಣವಾಗಿ ಸರಿಹೊಂದಿಸಬೇಕಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಕೆಲವು ಭಾಷೆಗಳು ಐಡೆಂಟಿಫೈಯರ್‌ಗಳಲ್ಲಿ ಯೂನಿಕೋಡ್ ಅಕ್ಷರಗಳನ್ನು ಅನುಮತಿಸಬಹುದು, ಇದಕ್ಕೆ ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ರೆಜೆಕ್ಸ್ ಅಗತ್ಯವಿರುತ್ತದೆ.

ಫೈನೈಟ್ ಆಟೋಮ್ಯಾಟಾ

ಫೈನೈಟ್ ಆಟೋಮ್ಯಾಟಾ (FA) ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳಿಂದ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಮಾದರಿಗಳನ್ನು ಗುರುತಿಸಲು ಬಳಸುವ ಅಮೂರ್ತ ಯಂತ್ರಗಳಾಗಿವೆ. ಅವು ಲೆಕ್ಸಿಕಲ್ ಅನಾಲೈಸರ್‌ಗಳ ಅನುಷ್ಠಾನದಲ್ಲಿ ಒಂದು ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಯಾಗಿದೆ. ಎರಡು ಮುಖ್ಯ ವಿಧದ ಫೈನೈಟ್ ಆಟೋಮ್ಯಾಟಾಗಳಿವೆ:

• ಡಿಟರ್ಮಿನಿಸ್ಟಿಕ್ ಫೈನೈಟ್ ಆಟೋಮ್ಯಾಟನ್ (DFA): ಪ್ರತಿ ಸ್ಥಿತಿ ಮತ್ತು ಇನ್‌ಪುಟ್ ಚಿಹ್ನೆಗೆ, ಇನ್ನೊಂದು ಸ್ಥಿತಿಗೆ ಕೇವಲ ಒಂದು ಪರಿವರ್ತನೆ ಇರುತ್ತದೆ. DFA ಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಸುಲಭ ಆದರೆ ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳಿಂದ ನೇರವಾಗಿ ನಿರ್ಮಿಸಲು ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾಗಬಹುದು.
• ನಾನ್-ಡಿಟರ್ಮಿನಿಸ್ಟಿಕ್ ಫೈನೈಟ್ ಆಟೋಮ್ಯಾಟನ್ (NFA): ಪ್ರತಿ ಸ್ಥಿತಿ ಮತ್ತು ಇನ್‌ಪುಟ್ ಚಿಹ್ನೆಗೆ, ಇತರ ಸ್ಥಿತಿಗಳಿಗೆ ಶೂನ್ಯ, ಒಂದು ಅಥವಾ ಬಹು ಪರಿವರ್ತನೆಗಳು ಇರಬಹುದು. NFA ಗಳನ್ನು ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳಿಂದ ನಿರ್ಮಿಸಲು ಸುಲಭ ಆದರೆ ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಅಲ್ಗಾರಿದಮ್‌ಗಳ ಅಗತ್ಯವಿರುತ್ತದೆ.

ಲೆಕ್ಸಿಕಲ್ ಅನಾಲಿಸಿಸ್‌ನಲ್ಲಿನ ವಿಶಿಷ್ಟ ಪ್ರಕ್ರಿಯೆಯು ಈ ಕೆಳಗಿನಂತಿರುತ್ತದೆ:

1. ಪ್ರತಿ ಟೋಕನ್ ಪ್ರಕಾರಕ್ಕೆ ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳನ್ನು NFA ಆಗಿ ಪರಿವರ್ತಿಸುವುದು.
2. NFA ಅನ್ನು DFA ಆಗಿ ಪರಿವರ್ತಿಸುವುದು.
3. DFA ಅನ್ನು ಟೇಬಲ್-ಚಾಲಿತ ಸ್ಕ್ಯಾನರ್ ಆಗಿ ಕಾರ್ಯಗತಗೊಳಿಸುವುದು.

ನಂತರ DFA ಅನ್ನು ಇನ್‌ಪುಟ್ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಸ್ಕ್ಯಾನ್ ಮಾಡಲು ಮತ್ತು ಟೋಕನ್‌ಗಳನ್ನು ಗುರುತಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. DFA ಆರಂಭಿಕ ಸ್ಥಿತಿಯಲ್ಲಿ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ಮತ್ತು ಇನ್‌ಪುಟ್ ಅನ್ನು ಅಕ್ಷರದಿಂದ ಅಕ್ಷರಕ್ಕೆ ಓದುತ್ತದೆ. ಪ್ರಸ್ತುತ ಸ್ಥಿತಿ ಮತ್ತು ಇನ್‌ಪುಟ್ ಅಕ್ಷರವನ್ನು ಆಧರಿಸಿ, ಅದು ಹೊಸ ಸ್ಥಿತಿಗೆ ಪರಿವರ್ತನೆಯಾಗುತ್ತದೆ. ಅಕ್ಷರಗಳ ಅನುಕ್ರಮವನ್ನು ಓದಿದ ನಂತರ DFA ಸ್ವೀಕರಿಸುವ ಸ್ಥಿತಿಯನ್ನು ತಲುಪಿದರೆ, ಅನುಕ್ರಮವನ್ನು ಲೆಕ್ಸೀಮ್ ಎಂದು ಗುರುತಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಅನುಗುಣವಾದ ಟೋಕನ್ ಅನ್ನು ರಚಿಸಲಾಗುತ್ತದೆ.

ಲೆಕ್ಸಿಕಲ್ ಅನಾಲಿಸಿಸ್ ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ

ಲೆಕ್ಸಿಕಲ್ ಅನಾಲೈಸರ್ ಈ ಕೆಳಗಿನಂತೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ:

1. ಸೋರ್ಸ್ ಕೋಡ್ ಓದುತ್ತದೆ: ಲೆಕ್ಸರ್ ಇನ್‌ಪುಟ್ ಫೈಲ್ ಅಥವಾ ಸ್ಟ್ರೀಮ್‌ನಿಂದ ಸೋರ್ಸ್ ಕೋಡ್ ಅನ್ನು ಅಕ್ಷರದಿಂದ ಅಕ್ಷರಕ್ಕೆ ಓದುತ್ತದೆ.
2. ಲೆಕ್ಸೀಮ್‌ಗಳನ್ನು ಗುರುತಿಸುತ್ತದೆ: ಲೆಕ್ಸರ್ ಮಾನ್ಯ ಲೆಕ್ಸೀಮ್‌ಗಳನ್ನು ರೂಪಿಸುವ ಅಕ್ಷರಗಳ ಅನುಕ್ರಮಗಳನ್ನು ಗುರುತಿಸಲು ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳನ್ನು (ಅಥವಾ, ಹೆಚ್ಚು ನಿಖರವಾಗಿ, ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳಿಂದ ಪಡೆದ DFA) ಬಳಸುತ್ತದೆ.
3. ಟೋಕನ್‌ಗಳನ್ನು ರಚಿಸುತ್ತದೆ: ಕಂಡುಬಂದ ಪ್ರತಿಯೊಂದು ಲೆಕ್ಸೀಮ್‌ಗಾಗಿ, ಲೆಕ್ಸರ್ ಒಂದು ಟೋಕನ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ, ಅದು ಲೆಕ್ಸೀಮ್ ಮತ್ತು ಅದರ ಟೋಕನ್ ಪ್ರಕಾರವನ್ನು (ಉದಾ., IDENTIFIER, INTEGER_LITERAL, OPERATOR) ಒಳಗೊಂಡಿರುತ್ತದೆ.
4. ದೋಷಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ: ಲೆಕ್ಸರ್ ಯಾವುದೇ ವ್ಯಾಖ್ಯಾನಿತ ಮಾದರಿಗೆ ಹೊಂದಿಕೆಯಾಗದ ಅಕ್ಷರಗಳ ಅನುಕ್ರಮವನ್ನು ಎದುರಿಸಿದರೆ (ಅಂದರೆ, ಅದನ್ನು ಟೋಕನೈಸ್ ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ), ಅದು ಲೆಕ್ಸಿಕಲ್ ದೋಷವನ್ನು ವರದಿ ಮಾಡುತ್ತದೆ. ಇದು ಅಮಾನ್ಯ ಅಕ್ಷರ ಅಥವಾ ಅಸಮರ್ಪಕವಾಗಿ ರೂಪುಗೊಂಡ ಐಡೆಂಟಿಫೈಯರ್ ಅನ್ನು ಒಳಗೊಂಡಿರಬಹುದು.
5. ಟೋಕನ್‌ಗಳನ್ನು ಪಾರ್ಸರ್‌ಗೆ ರವಾನಿಸುತ್ತದೆ: ಲೆಕ್ಸರ್ ಟೋಕನ್‌ಗಳ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಕಂಪೈಲರ್‌ನ ಮುಂದಿನ ಹಂತವಾದ ಪಾರ್ಸರ್‌ಗೆ ರವಾನಿಸುತ್ತದೆ.

ಈ ಸರಳ C ಕೋಡ್ ತುಣುಕನ್ನು ಪರಿಗಣಿಸಿ:

            int main() {
  int x = 10;
  return 0;
}
            

              
                Copy
              
            
          

ಲೆಕ್ಸಿಕಲ್ ಅನಾಲೈಸರ್ ಈ ಕೋಡ್ ಅನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಈ ಕೆಳಗಿನ ಟೋಕನ್‌ಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ (ಸರಳೀಕರಿಸಲಾಗಿದೆ):

• KEYWORD: `int`
• IDENTIFIER: `main`
• LEFT_PAREN: `(`
• RIGHT_PAREN: `)`
• LEFT_BRACE: `{`
• KEYWORD: `int`
• IDENTIFIER: `x`
• ASSIGNMENT_OPERATOR: `=`
• INTEGER_LITERAL: `10`
• SEMICOLON: `;`
• KEYWORD: `return`
• INTEGER_LITERAL: `0`
• SEMICOLON: `;`
• RIGHT_BRACE: `}`

ಲೆಕ್ಸಿಕಲ್ ಅನಾಲೈಸರ್‌ನ ಪ್ರಾಯೋಗಿಕ ಅನುಷ್ಠಾನ

ಲೆಕ್ಸಿಕಲ್ ಅನಾಲೈಸರ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಎರಡು ಪ್ರಾಥಮಿಕ ವಿಧಾನಗಳಿವೆ:

1. ಹಸ್ತಚಾಲಿತ ಅನುಷ್ಠಾನ: ಲೆಕ್ಸರ್ ಕೋಡ್ ಅನ್ನು ಕೈಯಿಂದ ಬರೆಯುವುದು. ಇದು ಹೆಚ್ಚಿನ ನಿಯಂತ್ರಣ ಮತ್ತು ಆಪ್ಟಿಮೈಸೇಶನ್ ಸಾಧ್ಯತೆಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ ಆದರೆ ಹೆಚ್ಚು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ದೋಷ-ಪೀಡಿತವಾಗಿರುತ್ತದೆ.
2. ಲೆಕ್ಸರ್ ಜನರೇಟರ್‌ಗಳನ್ನು ಬಳಸುವುದು: Lex (Flex), ANTLR, ಅಥವಾ JFlex ನಂತಹ ಸಾಧನಗಳನ್ನು ಬಳಸುವುದು, ಇದು ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್ ವಿಶೇಷಣಗಳ ಆಧಾರದ ಮೇಲೆ ಲೆಕ್ಸರ್ ಕೋಡ್ ಅನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಉತ್ಪಾದಿಸುತ್ತದೆ.

ಹಸ್ತಚಾಲಿತ ಅನುಷ್ಠಾನ

ಹಸ್ತಚಾಲಿತ ಅನುಷ್ಠಾನವು ಸಾಮಾನ್ಯವಾಗಿ ಸ್ಟೇಟ್ ಮಷಿನ್ (DFA) ಅನ್ನು ರಚಿಸುವುದು ಮತ್ತು ಇನ್‌ಪುಟ್ ಅಕ್ಷರಗಳ ಆಧಾರದ ಮೇಲೆ ಸ್ಥಿತಿಗಳ ನಡುವೆ ಪರಿವರ್ತನೆಗೊಳ್ಳಲು ಕೋಡ್ ಬರೆಯುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಈ ವಿಧಾನವು ಲೆಕ್ಸಿಕಲ್ ಅನಾಲಿಸಿಸ್ ಪ್ರಕ್ರಿಯೆಯ ಮೇಲೆ ಸೂಕ್ಷ್ಮ-ಧಾನ್ಯದ ನಿಯಂತ್ರಣವನ್ನು ಅನುಮತಿಸುತ್ತದೆ ಮತ್ತು ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯಕ್ಷಮತೆಯ ಅವಶ್ಯಕತೆಗಳಿಗಾಗಿ ಆಪ್ಟಿಮೈಸ್ ಮಾಡಬಹುದು. ಆದಾಗ್ಯೂ, ಇದಕ್ಕೆ ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳು ಮತ್ತು ಫೈನೈಟ್ ಆಟೋಮ್ಯಾಟಾದ ಆಳವಾದ ತಿಳುವಳಿಕೆ ಅಗತ್ಯವಿರುತ್ತದೆ, ಮತ್ತು ಇದನ್ನು ನಿರ್ವಹಿಸುವುದು ಮತ್ತು ಡೀಬಗ್ ಮಾಡುವುದು ಸವಾಲಿನದ್ದಾಗಿರಬಹುದು.

ಪೈಥಾನ್‌ನಲ್ಲಿ ಹಸ್ತಚಾಲಿತ ಲೆಕ್ಸರ್ ಇಂಟಿಜರ್ ಲಿಟರಲ್‌ಗಳನ್ನು ಹೇಗೆ ನಿಭಾಯಿಸಬಹುದು ಎಂಬುದರ ಪರಿಕಲ್ಪನಾ (ಮತ್ತು ಹೆಚ್ಚು ಸರಳೀಕೃತ) ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:

            def lexer(input_string):
    tokens = []
    i = 0
    while i < len(input_string):
        if input_string[i].isdigit():
            # Found a digit, start building the integer
            num_str = ""
            while i < len(input_string) and input_string[i].isdigit():
                num_str += input_string[i]
                i += 1
            tokens.append(("INTEGER", int(num_str)))
            i -= 1 # Correct for the last increment
        elif input_string[i] == '+':
            tokens.append(("PLUS", "+"))
        elif input_string[i] == '-':
            tokens.append(("MINUS", "-"))
        # ... (handle other characters and tokens)
        i += 1
    return tokens
            

              
                Copy
              
            
          

ಇದು ಪ್ರಾಥಮಿಕ ಉದಾಹರಣೆಯಾಗಿದೆ, ಆದರೆ ಇದು ಇನ್‌ಪುಟ್ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ಓದುವ ಮತ್ತು ಅಕ್ಷರ ಮಾದರಿಗಳ ಆಧಾರದ ಮೇಲೆ ಟೋಕನ್‌ಗಳನ್ನು ಗುರುತಿಸುವ ಮೂಲಭೂತ ಕಲ್ಪನೆಯನ್ನು ವಿವರಿಸುತ್ತದೆ.

ಲೆಕ್ಸರ್ ಜನರೇಟರ್‌ಗಳು

ಲೆಕ್ಸರ್ ಜನರೇಟರ್‌ಗಳು ಲೆಕ್ಸಿಕಲ್ ಅನಾಲೈಸರ್‌ಗಳನ್ನು ರಚಿಸುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುವ ಸಾಧನಗಳಾಗಿವೆ. ಅವು ಇನ್‌ಪುಟ್ ಆಗಿ ವಿಶೇಷಣ ಫೈಲ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತವೆ, ಇದು ಪ್ರತಿ ಟೋಕನ್ ಪ್ರಕಾರಕ್ಕೆ ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳನ್ನು ಮತ್ತು ಟೋಕನ್ ಅನ್ನು ಗುರುತಿಸಿದಾಗ ನಿರ್ವಹಿಸಬೇಕಾದ ಕ್ರಿಯೆಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ. ನಂತರ ಜನರೇಟರ್ ಗುರಿ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯಲ್ಲಿ ಲೆಕ್ಸರ್ ಕೋಡ್ ಅನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ.

ಕೆಲವು ಜನಪ್ರಿಯ ಲೆಕ್ಸರ್ ಜನರೇಟರ್‌ಗಳು ಇಲ್ಲಿವೆ:

• Lex (Flex): ವ್ಯಾಪಕವಾಗಿ ಬಳಸಲಾಗುವ ಲೆಕ್ಸರ್ ಜನರೇಟರ್, ಇದನ್ನು ಸಾಮಾನ್ಯವಾಗಿ Yacc (Bison), ಪಾರ್ಸರ್ ಜನರೇಟರ್ ಜೊತೆಯಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ. Flex ಅದರ ವೇಗ ಮತ್ತು ದಕ್ಷತೆಗೆ ಹೆಸರುವಾಸಿಯಾಗಿದೆ.
• ANTLR (ANother Tool for Language Recognition): ಇದು ಒಂದು ಶಕ್ತಿಯುತ ಪಾರ್ಸರ್ ಜನರೇಟರ್ ಆಗಿದ್ದು, ಇದು ಲೆಕ್ಸರ್ ಜನರೇಟರ್ ಅನ್ನು ಸಹ ಒಳಗೊಂಡಿದೆ. ANTLR ವ್ಯಾಪಕ ಶ್ರೇಣಿಯ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ ಮತ್ತು ಸಂಕೀರ್ಣ ವ್ಯಾಕರಣಗಳು ಮತ್ತು ಲೆಕ್ಸರ್‌ಗಳನ್ನು ರಚಿಸಲು ಅನುಮತಿಸುತ್ತದೆ.
• JFlex: ಜಾವಾಕ್ಕಾಗಿ ವಿಶೇಷವಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ಲೆಕ್ಸರ್ ಜನರೇಟರ್. JFlex ದಕ್ಷ ಮತ್ತು ಹೆಚ್ಚು ಗ್ರಾಹಕೀಯಗೊಳಿಸಬಹುದಾದ ಲೆಕ್ಸರ್‌ಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ.

ಲೆಕ್ಸರ್ ಜನರೇಟರ್ ಬಳಸುವುದರಿಂದ ಹಲವಾರು ಪ್ರಯೋಜನಗಳಿವೆ:

• ಕಡಿಮೆಯಾದ ಅಭಿವೃದ್ಧಿ ಸಮಯ: ಲೆಕ್ಸರ್ ಜನರೇಟರ್‌ಗಳು ಲೆಕ್ಸಿಕಲ್ ಅನಾಲೈಸರ್ ಅನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಲು ಬೇಕಾದ ಸಮಯ ಮತ್ತು ಶ್ರಮವನ್ನು ಗಣನೀಯವಾಗಿ ಕಡಿಮೆ ಮಾಡುತ್ತವೆ.
• ಸುಧಾರಿತ ನಿಖರತೆ: ಲೆಕ್ಸರ್ ಜನರೇಟರ್‌ಗಳು ಸು-ವ್ಯಾಖ್ಯಾನಿತ ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳ ಆಧಾರದ ಮೇಲೆ ಲೆಕ್ಸರ್‌ಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತವೆ, ದೋಷಗಳ ಅಪಾಯವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತವೆ.
• ನಿರ್ವಹಣೆ: ಲೆಕ್ಸರ್ ವಿಶೇಷಣವು ಸಾಮಾನ್ಯವಾಗಿ ಕೈಬರಹದ ಕೋಡ್‌ಗಿಂತ ಓದಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಸುಲಭವಾಗಿರುತ್ತದೆ.
• ಕಾರ್ಯಕ್ಷಮತೆ: ಆಧುನಿಕ ಲೆಕ್ಸರ್ ಜನರೇಟರ್‌ಗಳು ಅತ್ಯುತ್ತಮ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸಾಧಿಸಬಲ್ಲ ಹೆಚ್ಚು ಆಪ್ಟಿಮೈಸ್ಡ್ ಲೆಕ್ಸರ್‌ಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತವೆ.

ಇಂಟಿಜರ್‌ಗಳು ಮತ್ತು ಐಡೆಂಟಿಫೈಯರ್‌ಗಳನ್ನು ಗುರುತಿಸಲು ಸರಳವಾದ Flex ವಿಶೇಷಣದ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:

            %%
[0-9]+      { printf("INTEGER: %s\n", yytext); }
[a-zA-Z_][a-zA-Z0-9_]* { printf("IDENTIFIER: %s\n", yytext); }
[ \t\n]+  ; // Ignore whitespace
.           { printf("ILLEGAL CHARACTER: %s\n", yytext); }
%%

            

              
                Copy
              
            
          

ಈ ವಿಶೇಷಣವು ಎರಡು ನಿಯಮಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ: ಒಂದು ಇಂಟಿಜರ್‌ಗಳಿಗೆ ಮತ್ತು ಇನ್ನೊಂದು ಐಡೆಂಟಿಫೈಯರ್‌ಗಳಿಗೆ. Flex ಈ ವಿಶೇಷಣವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿದಾಗ, ಅದು ಈ ಟೋಕನ್‌ಗಳನ್ನು ಗುರುತಿಸುವ ಲೆಕ್ಸರ್‌ಗಾಗಿ C ಕೋಡ್ ಅನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ. `yytext` ವೇರಿಯೇಬಲ್ ಹೊಂದಾಣಿಕೆಯಾದ ಲೆಕ್ಸೀಮ್ ಅನ್ನು ಹೊಂದಿರುತ್ತದೆ.

ಲೆಕ್ಸಿಕಲ್ ಅನಾಲಿಸಿಸ್‌ನಲ್ಲಿ ದೋಷ ನಿರ್ವಹಣೆ

ದೋಷ ನಿರ್ವಹಣೆ ಲೆಕ್ಸಿಕಲ್ ಅನಾಲಿಸಿಸ್‌ನ ಒಂದು ಪ್ರಮುಖ ಅಂಶವಾಗಿದೆ. ಲೆಕ್ಸರ್ ಅಮಾನ್ಯ ಅಕ್ಷರ ಅಥವಾ ಅಸಮರ್ಪಕವಾಗಿ ರೂಪುಗೊಂಡ ಲೆಕ್ಸೀಮ್ ಅನ್ನು ಎದುರಿಸಿದಾಗ, ಅದು ಬಳಕೆದಾರರಿಗೆ ದೋಷವನ್ನು ವರದಿ ಮಾಡಬೇಕಾಗುತ್ತದೆ. ಸಾಮಾನ್ಯ ಲೆಕ್ಸಿಕಲ್ ದೋಷಗಳು ಸೇರಿವೆ:

• ಅಮಾನ್ಯ ಅಕ್ಷರಗಳು: ಭಾಷೆಯ ವರ್ಣಮಾಲೆಯ ಭಾಗವಲ್ಲದ ಅಕ್ಷರಗಳು (ಉದಾ., ಐಡೆಂಟಿಫೈಯರ್‌ಗಳಲ್ಲಿ ಅನುಮತಿಸದ ಭಾಷೆಯಲ್ಲಿ `$` ಚಿಹ್ನೆ).
• ಮುಗಿಯದ ಸ್ಟ್ರಿಂಗ್‌ಗಳು: ಹೊಂದಾಣಿಕೆಯ ಉದ್ಧರಣ ಚಿಹ್ನೆಯೊಂದಿಗೆ ಮುಚ್ಚದ ಸ್ಟ್ರಿಂಗ್‌ಗಳು.
• ಅಮಾನ್ಯ ಸಂಖ್ಯೆಗಳು: ಸರಿಯಾಗಿ ರೂಪುಗೊಳ್ಳದ ಸಂಖ್ಯೆಗಳು (ಉದಾ., ಬಹು ದಶಮಾಂಶ ಬಿಂದುಗಳನ್ನು ಹೊಂದಿರುವ ಸಂಖ್ಯೆ).
• ಗರಿಷ್ಠ ಉದ್ದವನ್ನು ಮೀರುವುದು: ಅನುಮತಿಸಲಾದ ಗರಿಷ್ಠ ಉದ್ದವನ್ನು ಮೀರಿದ ಐಡೆಂಟಿಫೈಯರ್‌ಗಳು ಅಥವಾ ಸ್ಟ್ರಿಂಗ್ ಲಿಟರಲ್‌ಗಳು.

ಲೆಕ್ಸಿಕಲ್ ದೋಷ ಪತ್ತೆಯಾದಾಗ, ಲೆಕ್ಸರ್ ಹೀಗೆ ಮಾಡಬೇಕು:

1. ದೋಷವನ್ನು ವರದಿ ಮಾಡಿ: ದೋಷ ಸಂಭವಿಸಿದ ಸಾಲು ಸಂಖ್ಯೆ ಮತ್ತು ಕಾಲಮ್ ಸಂಖ್ಯೆ, ಹಾಗೂ ದೋಷದ ವಿವರಣೆಯನ್ನು ಒಳಗೊಂಡ ದೋಷ ಸಂದೇಶವನ್ನು ರಚಿಸಿ.
2. ಚೇತರಿಸಿಕೊಳ್ಳಲು ಪ್ರಯತ್ನಿಸಿ: ದೋಷದಿಂದ ಚೇತರಿಸಿಕೊಳ್ಳಲು ಮತ್ತು ಇನ್‌ಪುಟ್ ಅನ್ನು ಸ್ಕ್ಯಾನ್ ಮಾಡುವುದನ್ನು ಮುಂದುವರಿಸಲು ಪ್ರಯತ್ನಿಸಿ. ಇದು ಅಮಾನ್ಯ ಅಕ್ಷರಗಳನ್ನು ಬಿಟ್ಟುಬಿಡುವುದು ಅಥವಾ ಪ್ರಸ್ತುತ ಟೋಕನ್ ಅನ್ನು ಕೊನೆಗೊಳಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರಬಹುದು. ಕ್ಯಾಸ್ಕೇಡಿಂಗ್ ದೋಷಗಳನ್ನು ತಪ್ಪಿಸುವುದು ಮತ್ತು ಬಳಕೆದಾರರಿಗೆ ಸಾಧ್ಯವಾದಷ್ಟು ಹೆಚ್ಚಿನ ಮಾಹಿತಿಯನ್ನು ಒದಗಿಸುವುದು ಗುರಿಯಾಗಿದೆ.

ದೋಷ ಸಂದೇಶಗಳು ಸ್ಪಷ್ಟ ಮತ್ತು ಮಾಹಿತಿಯುಕ್ತವಾಗಿರಬೇಕು, ಪ್ರೋಗ್ರಾಮರ್‌ಗೆ ಸಮಸ್ಯೆಯನ್ನು ತ್ವರಿತವಾಗಿ ಗುರುತಿಸಲು ಮತ್ತು ಸರಿಪಡಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಮುಗಿಯದ ಸ್ಟ್ರಿಂಗ್‌ಗೆ ಉತ್ತಮ ದೋಷ ಸಂದೇಶ ಹೀಗಿರಬಹುದು: `Error: Unterminated string literal at line 10, column 25`.

ಸಂಕಲನ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ಲೆಕ್ಸಿಕಲ್ ಅನಾಲಿಸಿಸ್‌ನ ಪಾತ್ರ

ಲೆಕ್ಸಿಕಲ್ ಅನಾಲಿಸಿಸ್ ಸಂಕಲನ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ನಿರ್ಣಾಯಕ ಮೊದಲ ಹೆಜ್ಜೆಯಾಗಿದೆ. ಅದರ ಔಟ್‌ಪುಟ್, ಟೋಕನ್‌ಗಳ ಸ್ಟ್ರೀಮ್, ಮುಂದಿನ ಹಂತವಾದ ಪಾರ್ಸರ್ (ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನಾಲೈಸರ್) ಗೆ ಇನ್‌ಪುಟ್ ಆಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಪಾರ್ಸರ್ ಪ್ರೋಗ್ರಾಂನ ವ್ಯಾಕರಣ ರಚನೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಅಮೂರ್ತ ಸಿಂಟ್ಯಾಕ್ಸ್ ಟ್ರೀ (AST) ಅನ್ನು ನಿರ್ಮಿಸಲು ಟೋಕನ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ. ನಿಖರ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹ ಲೆಕ್ಸಿಕಲ್ ಅನಾಲಿಸಿಸ್ ಇಲ್ಲದೆ, ಪಾರ್ಸರ್ ಸೋರ್ಸ್ ಕೋಡ್ ಅನ್ನು ಸರಿಯಾಗಿ ಅರ್ಥೈಸಲು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ.

ಲೆಕ್ಸಿಕಲ್ ಅನಾಲಿಸಿಸ್ ಮತ್ತು ಪಾರ್ಸಿಂಗ್ ನಡುವಿನ ಸಂಬಂಧವನ್ನು ಈ ಕೆಳಗಿನಂತೆ ಸಂಕ್ಷಿಪ್ತಗೊಳಿಸಬಹುದು:

• ಲೆಕ್ಸಿಕಲ್ ಅನಾಲಿಸಿಸ್: ಸೋರ್ಸ್ ಕೋಡ್ ಅನ್ನು ಟೋಕನ್‌ಗಳ ಸ್ಟ್ರೀಮ್ ಆಗಿ ವಿಭಜಿಸುತ್ತದೆ.
• ಪಾರ್ಸಿಂಗ್: ಟೋಕನ್ ಸ್ಟ್ರೀಮ್‌ನ ರಚನೆಯನ್ನು ವಿಶ್ಲೇಷಿಸುತ್ತದೆ ಮತ್ತು ಅಮೂರ್ತ ಸಿಂಟ್ಯಾಕ್ಸ್ ಟ್ರೀ (AST) ಅನ್ನು ನಿರ್ಮಿಸುತ್ತದೆ.

ನಂತರ AST ಅನ್ನು ಕಂಪೈಲರ್‌ನ ನಂತರದ ಹಂತಗಳಾದ ಸೆಮ್ಯಾಂಟಿಕ್ ಅನಾಲಿಸಿಸ್, ಮಧ್ಯಂತರ ಕೋಡ್ ಉತ್ಪಾದನೆ ಮತ್ತು ಕೋಡ್ ಆಪ್ಟಿಮೈಸೇಶನ್‌ನಿಂದ ಅಂತಿಮ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಕೋಡ್ ಅನ್ನು ಉತ್ಪಾದಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ.

ಲೆಕ್ಸಿಕಲ್ ಅನಾಲಿಸಿಸ್‌ನಲ್ಲಿನ ಸುಧಾರಿತ ವಿಷಯಗಳು

ಈ ಲೇಖನವು ಲೆಕ್ಸಿಕಲ್ ಅನಾಲಿಸಿಸ್‌ನ ಮೂಲಭೂತ ಅಂಶಗಳನ್ನು ಒಳಗೊಂಡಿದ್ದರೂ, ಅನ್ವೇಷಿಸಲು ಯೋಗ್ಯವಾದ ಹಲವಾರು ಸುಧಾರಿತ ವಿಷಯಗಳಿವೆ:

• ಯೂನಿಕೋಡ್ ಬೆಂಬಲ: ಐಡೆಂಟಿಫೈಯರ್‌ಗಳು ಮತ್ತು ಸ್ಟ್ರಿಂಗ್ ಲಿಟರಲ್‌ಗಳಲ್ಲಿ ಯೂನಿಕೋಡ್ ಅಕ್ಷರಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು. ಇದಕ್ಕೆ ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳು ಮತ್ತು ಅಕ್ಷರ ವರ್ಗೀಕರಣ ತಂತ್ರಗಳು ಬೇಕಾಗುತ್ತವೆ.
• ಎಂಬೆಡೆಡ್ ಭಾಷೆಗಳಿಗಾಗಿ ಲೆಕ್ಸಿಕಲ್ ಅನಾಲಿಸಿಸ್: ಇತರ ಭಾಷೆಗಳಲ್ಲಿ ಎಂಬೆಡ್ ಮಾಡಲಾದ ಭಾಷೆಗಳಿಗಾಗಿ ಲೆಕ್ಸಿಕಲ್ ಅನಾಲಿಸಿಸ್ (ಉದಾ., ಜಾವಾದಲ್ಲಿ ಎಂಬೆಡ್ ಮಾಡಲಾದ SQL). ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಸಂದರ್ಭವನ್ನು ಆಧರಿಸಿ ವಿಭಿನ್ನ ಲೆಕ್ಸರ್‌ಗಳ ನಡುವೆ ಬದಲಾಯಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ.
• ಇನ್‌ಕ್ರಿಮೆಂಟಲ್ ಲೆಕ್ಸಿಕಲ್ ಅನಾಲಿಸಿಸ್: ಬದಲಾಗಿರುವ ಸೋರ್ಸ್ ಕೋಡ್‌ನ ಭಾಗಗಳನ್ನು ಮಾತ್ರ ಸಮರ್ಥವಾಗಿ ಮರು-ಸ್ಕ್ಯಾನ್ ಮಾಡಬಲ್ಲ ಲೆಕ್ಸಿಕಲ್ ಅನಾಲಿಸಿಸ್, ಇದು ಸಂವಾದಾತ್ಮಕ ಅಭಿವೃದ್ಧಿ ಪರಿಸರಗಳಲ್ಲಿ ಉಪಯುಕ್ತವಾಗಿದೆ.
• ಸಂದರ್ಭ-ಸೂಕ್ಷ್ಮ ಲೆಕ್ಸಿಕಲ್ ಅನಾಲಿಸಿಸ್: ಟೋಕನ್ ಪ್ರಕಾರವು ಸುತ್ತಮುತ್ತಲಿನ ಸಂದರ್ಭವನ್ನು ಅವಲಂಬಿಸಿರುವ ಲೆಕ್ಸಿಕಲ್ ಅನಾಲಿಸಿಸ್. ಭಾಷೆಯ ಸಿಂಟ್ಯಾಕ್ಸ್‌ನಲ್ಲಿನ ಅಸ್ಪಷ್ಟತೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಇದನ್ನು ಬಳಸಬಹುದು.

ಅಂತಾರಾಷ್ಟ್ರೀಕರಣದ ಪರಿಗಣನೆಗಳು

ಜಾಗತಿಕ ಬಳಕೆಗಾಗಿ ಉದ್ದೇಶಿಸಲಾದ ಭಾಷೆಗಾಗಿ ಕಂಪೈಲರ್ ಅನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸುವಾಗ, ಲೆಕ್ಸಿಕಲ್ ಅನಾಲಿಸಿಸ್‌ಗಾಗಿ ಈ ಅಂತಾರಾಷ್ಟ್ರೀಕರಣದ ಅಂಶಗಳನ್ನು ಪರಿಗಣಿಸಿ:

• ಅಕ್ಷರ ಎನ್‌ಕೋಡಿಂಗ್: ವಿಭಿನ್ನ ವರ್ಣಮಾಲೆಗಳು ಮತ್ತು ಅಕ್ಷರ ಸೆಟ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ವಿವಿಧ ಅಕ್ಷರ ಎನ್‌ಕೋಡಿಂಗ್‌ಗಳಿಗೆ (UTF-8, UTF-16, ಇತ್ಯಾದಿ) ಬೆಂಬಲ.
• ಲೊಕೇಲ್-ನಿರ್ದಿಷ್ಟ ಫಾರ್ಮ್ಯಾಟಿಂಗ್: ಲೊಕೇಲ್-ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆ ಮತ್ತು ದಿನಾಂಕ ಸ್ವರೂಪಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು. ಉದಾಹರಣೆಗೆ, ದಶಮಾಂಶ ವಿಭಜಕವು ಕೆಲವು ಲೊಕೇಲ್‌ಗಳಲ್ಲಿ ಅವಧಿ (`.`) ಬದಲಿಗೆ ಕಾಮಾ (`,`) ಆಗಿರಬಹುದು.
• ಯೂನಿಕೋಡ್ ಸಾಮಾನ್ಯೀಕರಣ: ಸ್ಥಿರ ಹೋಲಿಕೆ ಮತ್ತು ಹೊಂದಾಣಿಕೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಯೂನಿಕೋಡ್ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಸಾಮಾನ್ಯೀಕರಿಸುವುದು.

ಅಂತಾರಾಷ್ಟ್ರೀಕರಣವನ್ನು ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸಲು ವಿಫಲವಾದರೆ ವಿಭಿನ್ನ ಭಾಷೆಗಳಲ್ಲಿ ಬರೆಯಲಾದ ಅಥವಾ ವಿಭಿನ್ನ ಅಕ್ಷರ ಸೆಟ್‌ಗಳನ್ನು ಬಳಸುವ ಸೋರ್ಸ್ ಕೋಡ್‌ನೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ತಪ್ಪಾದ ಟೋಕನೈಸೇಶನ್ ಮತ್ತು ಸಂಕಲನ ದೋಷಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು.

ತೀರ್ಮಾನ

ಲೆಕ್ಸಿಕಲ್ ಅನಾಲಿಸಿಸ್ ಕಂಪೈಲರ್ ವಿನ್ಯಾಸದ ಒಂದು ಮೂಲಭೂತ ಅಂಶವಾಗಿದೆ. ಈ ಲೇಖನದಲ್ಲಿ ಚರ್ಚಿಸಲಾದ ಪರಿಕಲ್ಪನೆಗಳ ಆಳವಾದ ತಿಳುವಳಿಕೆಯು ಕಂಪೈಲರ್‌ಗಳು, ಇಂಟರ್ಪ್ರಿಟರ್‌ಗಳು ಅಥವಾ ಇತರ ಭಾಷಾ ಸಂಸ್ಕರಣಾ ಸಾಧನಗಳನ್ನು ರಚಿಸುವಲ್ಲಿ ಅಥವಾ ಕೆಲಸ ಮಾಡುವಲ್ಲಿ ತೊಡಗಿರುವ ಯಾರಿಗಾದರೂ ಅತ್ಯಗತ್ಯ. ಟೋಕನ್‌ಗಳು ಮತ್ತು ಲೆಕ್ಸೀಮ್‌ಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದರಿಂದ ಹಿಡಿದು ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳು ಮತ್ತು ಫೈನೈಟ್ ಆಟೋಮ್ಯಾಟಾವನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವವರೆಗೆ, ಲೆಕ್ಸಿಕಲ್ ಅನಾಲಿಸಿಸ್‌ನ ಜ್ಞಾನವು ಕಂಪೈಲರ್ ನಿರ್ಮಾಣದ ಜಗತ್ತಿನಲ್ಲಿ ಮತ್ತಷ್ಟು ಅನ್ವೇಷಣೆಗೆ ಬಲವಾದ ಅಡಿಪಾಯವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಲೆಕ್ಸರ್ ಜನರೇಟರ್‌ಗಳನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳುವ ಮೂಲಕ ಮತ್ತು ಅಂತಾರಾಷ್ಟ್ರೀಕರಣದ ಅಂಶಗಳನ್ನು ಪರಿಗಣಿಸುವ ಮೂಲಕ, ಅಭಿವರ್ಧಕರು ವ್ಯಾಪಕ ಶ್ರೇಣಿಯ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳು ಮತ್ತು ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಳಿಗಾಗಿ ದೃಢವಾದ ಮತ್ತು ಸಮರ್ಥವಾದ ಲೆಕ್ಸಿಕಲ್ ಅನಾಲೈಸರ್‌ಗಳನ್ನು ರಚಿಸಬಹುದು. ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿಯು ವಿಕಸನಗೊಳ್ಳುತ್ತಲೇ ಇರುವುದರಿಂದ, ಲೆಕ್ಸಿಕಲ್ ಅನಾಲಿಸಿಸ್‌ನ ತತ್ವಗಳು ಜಾಗತಿಕವಾಗಿ ಭಾಷಾ ಸಂಸ್ಕರಣಾ ತಂತ್ರಜ್ಞಾನದ ಮೂಲಾಧಾರವಾಗಿ ಉಳಿಯುತ್ತವೆ.