CS456 - Systems Programming

Lessons:

• Makefiles, GDB and Memory

  An introduction to make and Makefiles, a GDB quick howto and the memory layout of Unix processes

• Basic file I/O & pipes

  In Unix, everything is a file, basic I/O system calls and pipes.

• X86_64 Assembly:
  
  
  • Asm Lesson 1 - The Central Processing Unit (CPU)

    Introduction to the CPU, registers, the flag register, assembly instructions and address/values.

  • Asm Lesson 2 - Registers, Memory layout, System calls and NASM

    Parts of a register, Linux process memory layout, Register usage during system calls and the Netwide Assembler (NASM)

  • Asm Lesson 3 - Machine Language / Instructions (part 1)

    Comparing data and jumps, C to Assembly translations

  • Asm Lesson 4 - Machine Language / Instructions (part 2)

    Copying data, Looping, Functions and the stack, Arithmetic operations

  • Asm Lesson 5 - The hardware stack

    Using the stack for temporary local variables.

  • Asm Lesson 6 - The C library, The heap, C pointers in assembly

    Using the C library from assembly, The C dynamic memory heap allocation functions and C pointers to assembly guide

• Tokenization and expressions
  
  
  • Tokenization and expressions part 1 - The strtok(3) C library function

    Using and implementing the strtok() library function for string tokenization.

  • Tokenization and expressions part 2 - Tokenization (Lexical Analysis)

    Implementing a simple lexer to lex a basic arithmetic expression and using it to implement an RPN calculator.

  • Tokenization and expressions part 3 - The Shunting-yard Algorithm

    Implementing the shunting yard algorithm to evaluate simple infix notation expressions.

  • Tokenization and expressions part 4 - Compiling an expression

    Conversion of the shunting yard code into a very basic expression compiler.

  • Tokenization and expressions part 5 - Adding variables to Shunting Yard

    Changes to the original shunting yard code to add support for variables.

• Creating an interpreter
  
  
  • Building an interpreter part 1 - Expression trees

    Introduction to expression trees and using the Shunting Yard algorithm to generate them.

  • Building an interpreter part 2 - Grammar and Syntax

    Discussion of grammar and syntax and changes to the lexer.

  • Building an interpreter part 3 - Generating the expression tree

    Changes to the shunting yard algorithm to generate expression trees.

  • Building an interpreter part 4 - Generating the AST

    Covers parsing the syntax of our language and generating the Abstact Syntax Tree (AST)

  • Building an interpreter part 5 - Evaluating the AST

    Covers run-time evaluation of the AST and expression trees

  • Compiling the AST

    Covers compilation and code-generation of the AST and expression trees.

• Creating a Unix shell
  
  
  • The Unix Shell 1

    Covers the fork() and execve() system calls.

  • The Unix Shell 2

    Covers signals, signal handlers, sending signals and SIGCHLD and the wait/waitpid system calls.

  • The Unix Shell 3

    Covers pipe and dup/dup2 system calls.

  • The Unix Shell 4

    Covers I/O redirection and constructing a pipeline.

  • The Unix Shell 5

    Covers the main parse loop and command stack management.

  • The Unix Shell 6

    Covers invocation, shell built-ins and a simple process table.

  • The Unix Shell 7

    Creating a Unix Shell 7 - Controlling the Terminal and Job Control