Writing Parsers in C++ ( for MathExpressions / SQL etc )

Understand how lexical parsers generate tokens from input by applying the longest matching regular expression. In a tie, the first rule wins.

Develop parser infrastructure for a Lex-style parser, enabling moving back and forth and jumping to input positions, and implement lexical stack, APIs, and checkpoint and restore checkpoint macros.

Set up the lexical stack to store lax data from lexer calls, including token code, wai wai text, and length, using a max-size 512 parser stack with push and pop.

Demonstrates writing a demo parser in C++ to recognize circle and ellipse equations, using lexical stack management, token validation, and debugging with GDB.

Explore production rules in a context-free grammar that generate alternating a and b strings, with the starting symbol, and see how parsers derive the rule sequence for mathematical expressions.

Develop parsers in C++ for math expressions and SQL by implementing grammar G2 through an exercise, engaging practical grammar construction.

Explore list generation in context-free grammars, using recursive productions to build lists of identifiers or integers with separators, and apply this to select queries with comma separated columns.

Explain production rules for parsing SQL queries, focusing on generating a list of columns using nonterminal symbols, and implement the longer rule first before the shorter when rules overlap.

Develop a library to parse, validate, and compute mathematical expressions, inequalities, and logical expressions using infix to postfix conversion and an expression tree in c++ as a static library.

The lecture shows parsing mathematical expressions with grammars, a lexical stack, and infix-to-postfix conversion to build an expression tree, extending to plus, minus, multiply, divide, and nested brackets.

Learn how to identify and remove left recursion in grammars for mathematical expressions, transforming left-recursive productions into equivalent, non-recursive rules ready for implementation in programming languages.

Add production rules to extend grammar: Q expands to E inequality E, and inequality expands to a comparison operator; implement functions q and inequality in the expression parser as homework.

Implement infix to postfix conversion in c++, converting a lexical stack in infix notation to a postfix array of pointers to data objects, with operator, parentheses, and inequality support.

Advance the infix to postfix algorithm by adding support for binary operators (max, min, pow, inequalities) and unary operators (square, square root) via grammar extensions and new parser functions.

See how a postfix expression is converted into an expression tree, with operator nodes and leaf operands like variables, integers, and doubles.

Add new data type classes to a C++ parser, enabling seamless handling of math expressions and SQL-like syntax.

Extend a C++ parser by adding new operator classes to support math expressions and SQL-style syntax.

Implement concrete operator and operand classes for int, double, and string data types, extend the dtype framework, and prepare for sql-like and where clause style expressions.

Learn to add two virtual set value functions to the D type base class and implement them in derived operand classes, using the token value pointer from the postfix array.

Implement the postfix to expression tree algorithm using a stack to build operand and operator nodes, handling unary and binary operators, and assigning the root at completion.

Explore validating and evaluating expression trees via postorder traversal, handling mixed operand types and invalid operands, and learn to implement a virtual clone function for the node hierarchy.

Validate an expression tree by ensuring operators have compatible operands. Use wildcard for unknown variable types and implement a result_storage_type across operator and operand classes, illustrated with the plus rules.

Implement postorder traversal based validation in the expression tree to ensure the return data type is not invalid. Validate via infix-to-postfix tests, including a case with numeric plus string.

Implement the evaluate API using a postorder traversal to compute an expression tree and ensure memory safety by deleting data after use; validate results via downcasting to supported data types.

Explore operand resolution in writing parsers in C++, defining data type variable operands, wiring a data source and read function, and evaluating expression trees only after all operands are resolved.

Demonstrates resolving datatype variable operand nodes by binding them to a memory cache and a lookup function, updating values per row, then evaluating the expression tree.

Implement operand resolution by adding a new data type variable and extending the expression tree to handle variable operands, including resolve logic, data source linkage, and strict validation.

Learn to parse and evaluate logical expressions using and and or with correct precedence. See how expression trees reflect operator order in sql where clauses and http get requests.

Extend the C++ expression parser to parse logical expressions by implementing a left-recursion-free grammar with and/or operators and inequalities, and apply the prescribed pass functions.