🧾 C1 Language Parser – Updated
Documentation with Line-by-Line
Explanation
📄 Line-by-line Code Explanation
import re
● Purpose: Imports the re module which allows the use of regular expressions for pattern
matching and parsing code.
type_keywords = {'int', 'float', 'char', 'double', 'long', 'short', 'string'}
all_keywords = type_keywords.union({'main', 'function'})
● Purpose:
●​ type_keywords defines the allowed data types in the language.​
●​ all_keywords extends this set to include reserved words such as main and
function.​
decl_pattern =
r'^(int|float|char|double|long|short|string)\s+[a-zA-Z_][a-zA-Z0-9_]*(\[\d+\])?(\s*=\s*[^;]+)?;$'
● Purpose: Matches valid variable declarations, optionally including array brackets and
initialization.
assign_pattern = r'^[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*[^;]+;$'
● Purpose: Matches valid assignment statements like x = 10;.
main_pattern = r'^main\s*\(\s*\)\s*\{$'
function_pattern = r'^function\s+[a-zA-Z_][a-zA-Z0-9_]*\s*\(\s*\)\s*\{$'
dictionary_pattern = r'^[a-zA-Z_][a-zA-Z0-9_]*\s*\{$'
● Purpose:
●​ main_pattern: Matches main() block opening.​
●​ function_pattern: Matches function functionName() { pattern.​
●​ dictionary_pattern: Matches blocks like blockName {.​
PUNCTUATORS = {';', '{', '}', '(', ')', '[', ']', ','}
OPERATORS = {'+', '-', '*', '/', '>', '<', '==', '='}
● Purpose: Define sets of punctuation symbols and operators for use in tokenization.
token_specification = [
('KEYWORD', r'\b(?:int|float|char|double|long|short|string|main|function)\b'),
('IDENTIFIER', r'[a-zA-Z_][a-zA-Z0-9_]*'),
('FLOAT_LITERAL', r'\d+\.\d+'),
('INT_LITERAL', r'\d+'),
('STRING_LITERAL', r'"[^"]*"'),
('OPERATOR', r'==|=|\+|-|\*|/|>|<'),
('PUNCTUATOR', r'[;{}\(\)\[\],]'),
('SKIP', r'[ \t]+'),
('MISMATCH', r'.'),
]
● Purpose: Specifies token types and their regex patterns for breaking each line into
meaningful parts:
●​ Keywords, identifiers, literals, operators, punctuators, etc.​
token_regex = '|'.join(f'(?P<{name}>{pattern})' for name, pattern in token_specification)
● Purpose: Dynamically compiles a single regular expression from all token specifications
using named groups.
def tokenize(line):
for match in re.finditer(token_regex, line):
kind = match.lastgroup
value = match.group()
if kind == 'SKIP':
continue
elif kind == 'MISMATCH':
print(f'Unexpected character: {value}')
else:
print(f'{kind}: {value}')
● Purpose: Defines a tokenizer function to parse each line and print categorized tokens.
Skips spaces and flags unmatched characters.
block_stack = []
var_decl_stack = []
main_found = False
● Purpose:
●​ block_stack: Keeps track of open blocks (main/function/other).​
●​ var_decl_stack: Maintains declared variables per block.​
●​ main_found: Flag to check if the main block exists.​
with open('input.txt', 'r') as file:
● Purpose: Opens the input file for reading line by line.
for line_number, line in enumerate(file, 1):
line = line.strip()
● Purpose: Iterates through each line, removes leading/trailing whitespace, and keeps track of
line numbers for error reporting.
if not line or line.startswith('//'):
continue
● Purpose: Skips empty lines and single-line comments.
if re.match(main_pattern, line):
block_stack.append('main')
var_decl_stack.append(set())
main_found = True
continue
● Purpose: Detects and opens the main block, adds to block and variable tracking, and sets
the main_found flag.
elif re.match(function_pattern, line):
block_stack.append('function')
var_decl_stack.append(set())
continue
● Purpose: Detects and opens a function block, adds to stacks.
elif re.match(dictionary_pattern, line):
block_stack.append('dictionary')
var_decl_stack.append(set())
continue
● Purpose: Detects a named block or "dictionary-style" block and tracks it.
elif line == '}':
if block_stack:
block_stack.pop()
var_decl_stack.pop()
else:
print(f'Line {line_number}: Unexpected closing brace')
continue
● Purpose: Handles closing blocks }, popping them from both the block and variable stacks.
Warns on unbalanced closing braces.
if not block_stack:
print(f'Line {line_number}: Code outside of any block is not allowed')
continue
● Purpose: Prevents code from being written outside of any block.
if re.match(decl_pattern, line):
● Purpose: Detects and handles variable declarations.
parts = line.split('=')
var_part = parts[0].strip()
var_name = var_part.split()[1].split('[')[0].strip()
● Purpose: Extracts the variable name, handling optional array declaration.
if var_name in var_decl_stack[-1]:
print(f'Line {line_number}: Variable "{var_name}" already declared in this scope')
elif var_name in all_keywords:
print(f'Line {line_number}: Variable name "{var_name}" cannot be a keyword')
else:
var_decl_stack[-1].add(var_name)
● Purpose: Checks for:
●​ Duplicate variable declarations within the same scope.​
●​ Keyword misuse as variable names.​
elif re.match(assign_pattern, line):
continue
● Purpose: Allows valid assignment statements to pass without error.
else:
print(f'Line {line_number}: Invalid syntax')
● Purpose: Catches all lines that do not match any known pattern and reports them as
invalid.
tokenize(line)
● Purpose: Tokenizes every valid line for syntax highlighting/debugging purposes.
if not main_found:
print('Error: main block not found')
if block_stack:
print('Error: Unclosed blocks exist')
● Purpose: Final validation:
●​ Confirms main() block is present.​
●​ Ensures all opened blocks are closed properly.​
Here are the syntax rules of the custom language in plain text format:
1. Variable Declarations
●​ Must begin with a type keyword (int, float, char, double, long, short, string)​
●​ Followed by a valid identifier​
●​ Optional array notation using square brackets​
●​ Optional assignment using =​
●​ Must end with a semicolon ;​
Examples:
●​ int x;​
●​ float y = 3.14;​
●​ string name = "Hazique";​
●​ int arr[10];​
●​ char c = 'a';​
2. Assignment Statements
●​ An identifier followed by = and a value or expression​
●​ Must end with a semicolon ;​
Examples:
●​ x = 10;​
●​ name = "John";​
3. Compound and Unary Assignments
●​ Supported operations include: ++, --, +=, -=​
●​ Can appear as prefix or postfix on identifiers​
●​ May optionally include assignment​
Examples:
●​ x++;​
●​ --y;​
●​ z += 5;​
●​ ++counter = 100; (though uncommon, it’s supported by the pattern)​
4. Function Definition
●​ Begins with keyword function​
●​ Followed by a valid function name and empty parentheses ()​
●​ Must be followed by a block { ... }​
Example:
●​ function myFunc() {​
5. Main Function
●​ Must be defined once using main()​
●​ Must be followed by a block { ... }​
●​ Serves as the entry point of the program​
Example:
●​ main() {​
6. Class Declaration
●​ Optional access modifier (public, private, or protected)​
●​ Must be followed by keyword class and a unique class name​
●​ Followed by a block { ... }​
Examples:
●​ class MyClass {​
●​ public class Car {​
7. Control Flow Statements
●​ If statement: starts with if, followed by condition in parentheses, and a block​
●​ Else statement: starts with else, followed by a block​
●​ For loop: for(init; condition; update) followed by a block​
Examples:
●​ if (x > 0) {​
●​ else {​
●​ for (int i = 0; i < 10; i++) {​
8. Dictionary-Like Block
●​ Identifier followed directly by an opening brace {​
Example:
●​ data {​
9. Empty Statement
●​ A single semicolon on a line is valid​
Example:
●​ ;​
10. Comments
●​ Lines starting with // are treated as comments and ignored​
Example:
●​ // This is a comment​
11. Syntax Rules and Restrictions
●​ Every opening { must have a matching closing }​
●​ All executable code must be inside a block​
●​ Variables cannot be declared multiple times in the same block​
●​ Variable names must not be reserved keywords​
●​ Only one main() is allowed​
●​ Classes must not be redeclared​
C1 Language CFG
<program>
::= <function_definition> | <program> <function_definition>
<function_definition> ::= <type> <identifier> "(" <parameter_list_opt> ")" "{"
<parameter_list_opt> ::= <parameter_list> | ε
<parameter_list>
::= <parameter> | <parameter> "," <parameter_list>
<parameter>
::= <type> <identifier>
<type>
::= "int"
| "float"
| "char"
| "double"
| "long"
| "short"
| "string"
<identifier>
::= <letter> <identifier_tail>
<identifier_tail>
::= <letter_or_digit> <identifier_tail> | ε
<letter>
<letter_or_digit>
::= [a-zA-Z_]
::= [a-zA-Z0-9_]
Explanation:
●​ <program> is a sequence of one or more function definitions.​
●​ A <function_definition> starts with a <type>, followed by an <identifier>
(function name), a parameter list in parentheses, and an opening curly brace {.​
●​ Parameters inside the parentheses can be empty (ε) or a comma-separated list of typed
identifiers.​
●​ <identifier> follows typical naming rules (letters or underscore followed by
letters/digits/underscore).​
●​ <type> includes the allowed data types only.​
Let me know if you want me to add variable declarations or statements inside function bodies as
well!