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.
Training Avaliability and Delivery
This is primarily ilt training
This course may be available for home-study
Computer Lab Work
ILT
This class may be available at a classroom in Bhubaneswar, Orissa,
Contact C IT ZEN Technologies for more information
For New batches of C, C++, JAVA,
RDBMS & Oracle 9i, PROJECTS, Pre-Placement Training, call 9437017636.
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.
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
About C IT ZEN Technologies - Training Provider
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...
