CI-LISP

Project Overview

CI-LISP is a minimalist Lisp interpreter developed in C that utilizes Flex for lexical analysis and Bison for parsing. This project demonstrates how to build an interpreter that can evaluate arithmetic expressions and handle function calls using an Abstract Syntax Tree (AST).

This was a school solo project, a shell of the .c,.y,.l, and .h files was provided and I completed the rest, it was not written from scratch.

Implementation Details

Components

cilisp.c – Contains the core implementation including error handling, AST node creation, and evaluation functions.
cilisp.h – Defines the data structures (such as AST nodes and return value types), function prototypes, and enums used throughout the project.
cilisp.l – The Flex file that tokenizes the input (identifying numbers, functions, and control characters).
cilisp.y – The Bison file that defines grammar rules, builds the AST, and manages parsing actions.

Key Functions and Features

The project features a modular design where:

createNumberNode and createFunctionNode build nodes for numbers and function expressions respectively.
eval and its helper functions traverse the AST to compute results, handling arithmetic operations like addition, subtraction, multiplication, and division.
Error handling is implemented via functions such as yyerror and warning, which output descriptive messages for issues like division by zero or memory allocation failures.
Integration with Flex/Bison enables conversion of s-expressions into an AST, making it easy to add new operations or modify the language grammar.

Code Snippets

Main Evaluation Function


// Evaluates an AST node and returns its computed value
RET_VAL eval(AST_NODE *node) {
    if (!node) {
        yyerror("NULL ast node passed into eval!");
        return NAN_RET_VAL;
    }
    switch (node->type) {
        case NUM_NODE_TYPE:
            return evalNumNode(node);
        case FUNC_NODE_TYPE:
            return evalFuncNode(node);
        default:
            warning("Unknown node type in eval");
            return NAN_RET_VAL;
    }
}

Flex Lexer (cilisp.l)


{double_pattern} {
    llog(DOUBLE);
    yylval.dval = strtod(yytext, NULL);
    return DOUBLE;
}

{int} {
    llog(INT);
    yylval.dval = strtod(yytext, NULL);
    return INT;
}

Bison Grammar Rule (cilisp.y)


s_expr:
    f_expr {
        $$ = $1;
    }
    | number {
        $$ = $1;
    }
    | QUIT {
        exit(EXIT_SUCCESS);
    }
    ;

Features

Builds an Abstract Syntax Tree (AST) to represent and evaluate s-expressions.
Supports arithmetic operations and functions such as add, sub, mult, and div.
Robust error handling with detailed warnings for invalid operations or inputs.
Uses Flex for tokenization and Bison for parsing, making the project highly modular.
Dynamic memory management for efficient AST node creation and deletion.

Usage

To compile CI-LISP, ensure you have Flex and Bison installed. Then run:


        yacc -d cilisp.y
        lex cilisp.l
        cat cilisp.c lex.yy.c y.tab.c > t.c
        gcc t.c -o cilisp -lm -lfl

Run the interpreter with:


./cilisp

CI-LISP will read from standard input.