Custom Search
Provided by: C IT ZEN Technologies

Compiler Writing in C

C Programming

Training Provided by C IT ZEN Technologies A compiler is a computer program that translates a computer program written in one computer language (called the source language) into an equivalent program written in another computer language (called the output or the target language).But, mostly we use compiler to mean those programs which translate source code written in a high level language to object code or machine language that may be directly executed by a computer or a virtual machine. However, translation from a low level language to a high level one is also possible; this is normally known as a decompiler if it is reconstructing a high level language program which (could have) generated the low level language program. Compilers also exist which translate from one high level language to another (cross compilers), or sometimes to an intermediate language that still needs further processing; these are sometimes known as cascaders. The purpose of a compiler is not just to make it easier to write good programs but also to make it harder to write bad ones. Catching errors during compilation saves testing. It also spares the greater cost of discovering the error later when it is harder to fix. An important aspect of undertaking training in compiler writing is to understand the key theoretical concepts normally taught in such a course. It is this philosophy that is being explored in the program. The trainees by undertaking the assignment of writing a compiler learn by practise and experimentation the various aspects of developing a good compiler.
This is primarily ilt training
study at homeThis course may be available for home-study
computer labComputer Lab Work
ILTILT
instructor led trainingThis class may be available at a classroom in Bhubaneswar, Orissa,
Contact C IT ZEN Technologies for more information
Course Level:advanced
Duration:99.99 hours
Training Presented in:English
Compiler Writing in C
    Home
 
  Training : C Unleashed : C Advanced Topics  
 
 
 

The topics below delve into two of the numerous application areas of C. They are –

1. Network Programming using Sockets

2. Compiler Writing



Network Programming using Sockets

Most operating systems provide precompiled programs that communicate across a network. Common examples into the TCP/IP world are web clients (browsers) and web servers, and the FTP and TELNET clients and servers. When we are using these utilities of the Internet sometimes we think about it but mostly we remain unaware about all the process involved. This program aims at learning and better understanding of these aspects by developing its own network programs using sockets. Sockets are basically “plug-ins” or endpoints at which the processes get connected and bi-directional communication takes place between them. Sockets, first introduced in Berkeley Unix, are a basic mechanism for IPC (Inter Process Communication) on a computer system, or on different computer systems connected by local or wide area networks. Of the various forms of IPC, sockets are by far the most popular. On any given platform, there are likely to be other forms of IPC that are faster, but for cross-platform communication, sockets are about the only game in town.

The program below explores the various aspects of IPC and its implementation through sockets. However, before taking up the program knowledge of Operating Systems and the networking protocols would be very helpful.

 
Module 1: System Programming
     

Basics of System Programming

  • System architecture
  • Needs of system calls
  • Linux System Architecture
 

System Calls

  • Portability Issue in System Calls
  • Aid for Programming
     
Module 2: Process Management
     

Defining a Process

  • Components of a Process
  • Environment of a Process

Process Scheduling

  • The nice() system call
  • The getpriority()/setpriority() system calls
  • Threads
  • Process Creation

Process Management Calls

  • The how of creating a Process
  • Process Control
  • Process Termination
 
  • Error Handling
  • Diagnostic of fork()

Process Overlaying

  • Diagnostic of exec
  • Process Limits

Exception Handling And Signals

  • Signals
  • The sigaction() system call
  • The signal() system call
  • The kill() system call
  • The alarm() system call
  • Error handling
    Top
Module 3: Inter Process Communication
     

Pipes

  • Creation of unnamed pipes
  • Limitation of Pipes
  • FIFOs – Named Pipes

Message Queues

  • Initializing a message queue
 
  • Controlling a message queue
  • Sending data to message queue
  • Retrieving data from message queue

Shared Memory

  • Accessing a shared memory segment
  • Attaching a Shared memory segment
  • Controlling a Shared Memory segment
     
Module 4: Advanced Inter Process Communication
     

Semaphores

  • What is semaphore
  • Initializing a semaphore set
  • Semaphore operations
  • Controlling Semaphores

Socket Programming

  • Socket programming interface
 
  • Socket services
  • Blocking and non-blocking calls
  • Transmission control block (TCB)
  • TCP socket programming
  • UDP socket programming
     
Module 5: Project Work
    Top
     

Complier Writing

A compiler is a computer program that translates a computer program written in one computer language (called the source language) into an equivalent program written in another computer language (called the output or the target language).But, mostly we use compiler to mean those programs which translate source code written in a high level language to object code or machine language that may be directly executed by a computer or a virtual machine. However, translation from a low level language to a high level one is also possible; this is normally known as a decompiler if it is reconstructing a high level language program which (could have) generated the low level language program. Compilers also exist which translate from one high level language to another (cross compilers), or sometimes to an intermediate language that still needs further processing; these are sometimes known as cascaders.

The purpose of a compiler is not just to make it easier to write good programs but also to make it harder to write bad ones. Catching errors during compilation saves testing. It also spares the greater cost of discovering the error later when it is harder to fix.

An important aspect of undertaking training in compiler writing is to understand the key theoretical concepts normally taught in such a course. It is this philosophy that is being explored in the program. The trainees by undertaking the assignment of writing a compiler learn by practise and experimentation the various aspects of developing a good compiler.

 
Module – 1 System Programming
     

Components of a programming system

  • Assembler / macro / compiler/ linker / loader / interpreter
  • Evolution of operating system

General machine structure

  • Memory
  • Register
  • Data
  • Instruction, special features

Machine language

  • Simple programming - No looping
  • Address Modification using instructions as Data
  • Address Modification using Index Register
  • Looping

Assembly Language

  • How to write a program using assembly language
  • Examples using literals
  • Design of an assembler
  • Statement of problem
  • Data structure
  • Format of databases
  • Algorithm
  • Look for modularity

Macro Instructions

  • Macro instruction arguments
  • Conditional Macro Expansion
  • Macro calls within macro
  • Macro instructions defining macros

Implementation of Macro

  • Single pass Assembler Algorithm
 
  • Two pass Assembler Algorithm
  • Implementation of macro calls within macros
  • Implementation within an assembler
  • General Loader Scheme
  • Absolute Loader
  • Subroutine Linkage
  • Relocating Loaders
  • Direct-linking Loaders
  • Design of an Absolute Loader

Design of a Direct-Linking Loader

  • Specification of Problem & Specification of Data Structures
  • Format of Data Bases
  • Algorithm

Compiler and translator

  • Lexical analyzer, parser
  • Intermediate Code Generator & Optimizer
  • Code Generation
  • Book Keeping & Error Handling

Programming Languages

  • High Level Programming Languages
  • What is a programming language
  • Lexical and syntactic structure of a language
  • Representation of programming language

Finite automata

  • From regular expressions to finite automata (NFA)
  • Interpreting an NFA – Theory & Implementation
  • Converting NFA to DFA – Theory & Implementation
  • DFA Minimization - Theory & Implementation

 

    Top
Module – 2 Compiler Construction
     

Lexical analyzer as a part of the compiler

  • Error recovery
  • Input Systems
  • Lexical Analysis
  • LEX – A lexical-Analyzer generator
  • Sentences, Parsers, and Context Free Grammars
  • Derivation and Sentential Forms
Parse Tree and Semantic Difficulties
  • E Productions
  • The End-of-Input marker
  • Right-linear grammars
  • Lists, recursion and Associativity
  • Expressions
  • Ambiguous Grammars
  • Syntax directed translation
  • Parsing
  • Shift reduced parsing
  • Operator-precedence parsing
  • Top Down Parsing / Bottom-up parser
  • Predictive Parser
  • Push-down Automata
  • Using a PDA for Top-Down Parse
  • Error recovery in a top-down Parser
  • Augmented Grammar and Table Driven Parser
  • Automating the Top-Down Parse Process
  • LL(1) Grammars and Their Limitations
  • Making the Parse Tables
  • Modifying Grammars
  • Implementing LL(1) parser
  • LLama – Implementing an LL(1) parser-generator
  • How bottom-up parsing works?
  • Recursion in Bottom-up parsing
  • Implementing the parser as a State Machine
  • Error Recovery in a LR parser
  • The value stack and attribute processing
  • Creating LR Parse Table
  • Representing LR state tables
  • Eliminating single reduction states
  • Implementing LALR(1) Parser – the Occs Output file
  • Parse file Generations
C- code - Intermediate Languages
  • Names and White space
  • Basic Types
  • The virtual machine: Registers, Stack and Memory
  • Memory Organizations: Segments
  • Variable Declarations: Storage Classes and Alignment
 
  • Addressing modes
  • Manipulating the stack
  • Subroutines
  • Stack Frames: Subroutine arguments and automatic variables

The Content of Symbol Table

  • Data structure for symbol tables
  • Representing scope information
  • Implementing symbol table
  • Representation of type & Implementation of type
  • Implementing the symbol-table Maintenance layer
  • The parser: configuration
  • Lexical Analyzer
  • Simple variable declaration
  • Structure and Union Declaration
  • Enumerated Type Declaration
  • Function Declaration
  • Compound Statement and Local Variable
  • Front-end – back-end consideration
  • The gen() subroutine
  • Expressions – Temporary variable
    About The Training Provider: C IT ZEN Technologies
    C IT ZEN Technologies - We at C IT ZEN offer our services at the student level to them who are pursuing various professional courses and are aiming for a successful career in IT. A student at his various stages of academics broadly requires three things. A proper training to explain the intricacies of the subjects, a suitable scope to apply the learnt techniques and a quality grooming to enable him to showcase his...
Do you offer c training training?
tcw11-gfc-v396M-10/25/09-10:15:22-()[B]-[B]-[B] -17:06:51