https://github.com/vinitkumar/mini-c-compiler

C compiler written by Mr. Atul Varma
https://github.com/vinitkumar/mini-c-compiler

Last synced: about 2 months ago
JSON representation

C compiler written by Mr. Atul Varma

• Host: GitHub
• URL: https://github.com/vinitkumar/mini-c-compiler
• Owner: vinitkumar
• Created: 2015-01-12T11:52:11.000Z (almost 10 years ago)
• Default Branch: master
• Last Pushed: 2023-08-16T16:30:34.000Z (over 1 year ago)
• Last Synced: 2024-10-12T12:08:45.705Z (2 months ago)
• Language: Python
• Homepage: https://github.com/toolness
• Size: 273 KB
• Stars: 18
• Watchers: 3
• Forks: 11
• Open Issues: 2
• Metadata Files:
  • Readme: README.md

Awesome Lists containing this project

README

        
[Atul](https://github.com/toolness)'s Mini-C Compiler

June 2, 2004

This is a compiler for a subset of the C programming language. It was

written in Python during the spring of 2004.

The lexer and parser were constructed using Dave Beazley's PLY (Python

Lex-Yacc), an open-source Python implementation of GNU

lex/yacc. Stages of compilation (symbol tree generation, type

checking, flow control checking, etc) are performed using an

object-oriented design pattern called a visitor (GoF 1995). The output

is annotated Intel 80x86 assembly, suitable for translation to machine

language using the GNU Assembler (GAS).

---------------------------------------------------------------

LANGUAGE FEATURES

---------------------------------------------------------------

The subset of the C language implemented here includes:

    * Functions, variables (local and global), and character and

      string literals.

    * Assignments (=, +=, etc), standard arithmetic binary and unary

      operators (+,-,*, etc), logical binary and unary operators (!,

      ==, <, etc).

    * Support for the C datatypes char and int, as well as implicit

      type conversion between the two (warnings are raised in

      situations of potential data loss). int variables are assumed to

      be signed, and char variables are assumed to be unsigned (this

      is not a violation of the ANSI C standard).

    * Control flow elements including while and for loops,

      if/then/else conditionals, and recursion.

    * Support for the C keywords extern for functions and variables,

      and static for functions.

    * Pointers, including pointer dereferencing (the * operator),

      multiple levels of indirection (double pointers, triple

      pointers, etc), array indexing notation, and the address-of (&)

      operator.

---------------------------------------------------------------

FILES AND DIRECTORIES

---------------------------------------------------------------

    lex.py       - Python Lex (this is part of PLY).

    yacc.py      - Python Yacc (this is part of PLY).

    clex.py      - Mini-C lexer.

    cparse.py    - Mini-C parser.  Contains yacc rules for Mini-C and

                   defines the classes that make up the AST.

    cvisitors.py - Mini-C visitors.  Defines the base visitor class,

                   and concrete visitor classes for printing the AST,

                   doing symbol table generation, type checking, and

                   flow control.

    cx86.py      - Intel 80x86 assembly code generator.  Defines a

                   virtual stack machine class and the code generator

                   visitor.

    c.py         - Front-end to the compiler.  This takes in command-

                   line options and runs the compiler on the filenames

                   you give it.

    samples/     - This directory contains foo.c and foo_lib.c, two

                   C files that can be compiled by the mini-c

                   compiler.  foo_lib.c is intended to be used as

                   a library that foo.c accesses, to show

                   that mini-c generates assembly that can be linked

                   with gcc.

---------------------------------------------------------------

USING THE COMPILER

---------------------------------------------------------------

The syntax for using the mini-c compiler is as follows:

    c.py  [[source-file-2] ...] [-ast] [-annotate]

Source files are the C files you want to compile into assembly (.s

files).

The '-ast' option generates a file with extension .ast that is a

printout of the abstract syntax tree for the source file, after

all stages of compilation occur.

The '-annotate' option generates annotated assembly.  That is,

assembly is generated with comments describing what each instruction

does, its relevance to the original C source code, and so forth.

Additional comments are inserted to delimit functions, control

structures, and so forth.

---------------------------------------------------------------

THE MAKEFILE

---------------------------------------------------------------

The makefile just compiles the two files in the samples/ directory and

outputs an executable called 'foo' into this directory (all other

output files are also placed here).

Note that while compiling this, you may receive a bunch of warnings

mentioning something about an "Illegal character: ''".  This is just

an artifact of newline translation differences between platforms and

should be ignored.