Lab Manual
User Manual:
Open the PDF directly: View PDF 
.
Page Count: 65
| Download | |
| Open PDF In Browser | View PDF |
Channabasaveshwara Institute of Technology
(Affiliated to VTU, Belgaum & Approved by AICTE, New Delhi)
(NAAC Accredited & ISO 9001:2015 Certified Institution)
NH 206 (B.H. Road), Gubbi, Tumkur – 572 216. Karnataka.
System Software and
Operating System Lab
Manual-15CSL67
Department of Computer Science & Engineering
VI Semester
2017-2018
Table of Contents
Page No.
Sl. No.
Particulars
1
2
3
4
5
6
7
Introduction to LEX
Introduction to YACC
Introduction to UNIX
Introduction to Operating Systems
Introduction to Compiler Design
Sample LEX and YACC programs
Lab Programs
Program 1 a) Write a LEX program to recognize valid
arithmetic expression. Identifiers in the expression
could be only integers and operators could be + and
*. Count the identifiers & operators present and print
them separately.
b) Write YACC program to evaluate arithmetic
expression involving operators: +, -, *, and /.
1
4
7
8
12
15
Develop, Implement and Execute a program using YACC
tool to recognize all strings ending with b preceded by n
a’s using the grammar an b (note: input n value).
Design, develop and implement YACC/C program to
construct Predictive / LL(1) Parsing Table for the
grammar rules: A aBa , B bB | . Use this table to
parse the sentence: abba$.
Design, develop and implement YACC/C program to
demonstrate Shift Reduce Parsing technique for the
grammar rules: E E+T | T, T T*F | F, F (E) | id
and parse the sentence: id + id * id.
Design, develop and implement a C/Java program to
generate the machine code using Triples for the statement
A = -B * (C +D) whose intermediate code in three-address
form:
T1 = -B
T2 = C + D
T3 = T1 + T2
A = T3
a) Write a LEX program to eliminate comment lines in a
C program and copy the resulting program into a separate
file.
b) Write YACC program to recognize valid identifier,
operators and keywords in the given text (C program)
file.
Design, develop and implement a C/C++/Java program to
simulate the working of Shortest remaining time and
Round Robin (RR) scheduling algorithms. Experiment
with different quantum sizes for RR algorithm.
Design, develop and implement a C/C++/Java program to
implement Banker’s algorithm. Assume suitable input
required to demonstrate the results.
20
Program 2
Program 3
Program 4
Program 5
Program 6
Program 7
Program 8
17
21
26
29
31
35
41
Design, develop and implement a C/C++/Java program to
implement page replacement algorithms LRU and FIFO.
Assume suitable input required to demonstrate the results.
Program 10 a) Design, develop and implement a C/C++/Java program
to simulate a numerical calculator.
b) Design, develop and implement a C/C++/Java program
to simulate page replacement technique.
Viva Questions
Program 9
8
45
49
59
Channabasaveshwara Institute of Technology
(Affiliated to VTU, Belgaum & Approved by AICTE, New Delhi)
(NAAC Accredited & ISO 9001:2015 Certified Institution)
NH 206 (B.H. Road), Gubbi, Tumkur – 572 216. Karnataka.
SYSTEM SOFTWARE AND OPERATING SYSTEM LABORATORY
[As per Choice Based Credit System (CBCS) scheme]
(Effective from the academic year 2016 -2017)
SEMESTER – VI
Subject Code
15CSL67
IA Marks
20
Number of Lecture
01I + 02P
Exam Marks
80
Hours/Week
Total Number of
40
Exam Hours
03
Lecture Hours
CREDITS – 02
Course objectives: This course will enable students to
To make students familiar with Lexical Analysis and Syntax Analysis phases of
Compiler Design and implement programs on these phases using LEX & YACC
tools and/or C/C++/Java
To enable students to learn different types of CPU scheduling algorithms used in
operating system.
To make students able to implement memory management - page replacement and
deadlock handling algorithms
Description (If any):
Exercises to be prepared with minimum three files (Where ever necessary):
i. Header file.
ii. Implementation file.
iii. Application file where main function will be present.
The idea behind using three files is to differentiate between the developer and user
sides. In the developer side, all the three files could be made visible. For the user side
only header file and application files could be made visible, which means that the
object code of the implementation file could be given to the user along with the
interface given in the header file, hiding the source file, if required. Avoid I/O
operations (printf/scanf) and use data input file where ever it is possible
Lab Experiments:
1.
a) Write a LEX program to recognize valid arithmetic expression. Identifiers in the
expression could be only integers and operators could be + and *. Count the identifiers
& operators present and print them separately.
b) Write YACC program to evaluate arithmetic expression involving operators: +, -,
*, and /.
2. Develop, Implement and Execute a program using YACC tool to recognize all
strings ending with b preceded by n a’s using the grammar an b (note: input n value).
3. Design, develop and implement YACC/C program to construct Predictive / LL(1)
Parsing Table for the grammar rules: A aBa , B bB | . Use this table to parse the
sentence: abba$
4. Design, develop and implement YACC/C program to demonstrate Shift Reduce
Parsing technique for the grammar rules: E E+T | T, T T*F | F, F (E) | id and
parse the sentence: id + id * id.
5. Design, develop and implement a C/Java program to generate the machine code
using Triples for the statement A = -B * (C +D) whose intermediate code in threeaddress form:
T1 = -B
T2 = C + D
T3 = T1 + T2
A = T3
6. a) Write a LEX program to eliminate comment lines in a C program and copy the
resulting program into a separate file.
b) Write YACC program to recognize valid identifier, operators and keywords in the
given text (C program) file.
7. Design, develop and implement a C/C++/Java program to simulate the working of
Shortest remaining time and Round Robin (RR) scheduling algorithms. Experiment
with different quantum sizes for RR algorithm.
8. Design, develop and implement a C/C++/Java program to implement Banker’s
algorithm. Assume suitable input required to demonstrate the results.
9. Design, develop and implement a C/C++/Java program to implement page
replacement algorithms LRU and FIFO. Assume suitable input required to
demonstrate the results.
10. a) Design, develop and implement a C/C++/Java program to simulate a numerical
calculator .
b) Design, develop and implement a C/C++/Java program to simulate page
replacement technique.
Note: In Examination, for question No 10: Students may be asked to execute any one
of the above (10(a) or 10(b)- Examiner choice)
Study Experiment / Project:
NIL
Course outcomes: The students should be able to:
Implement and demonstrate Lexer’s and Parser’s
Evaluate different algorithms required for management, scheduling, allocation and
communication used in operating system.
Conduction of Practical Examination:
All laboratory experiments are to be included for practical examination.
Students are allowed to pick one experiment from the lot.
Strictly follow the instructions as printed on the cover page of answer script.
Marks distribution: Procedure + Conduction + Viva: 20 + 50 +10 (80).
Change of experiment is allowed only once and marks allotted to the procedure
part to be made zero.
System Software and Operating System Lab-15CSL67
VI Semester CSE
1. INTRODUCTION TO LEX
Lex and YACC helps you write programs that transforms structured input. Lex
generates C code for lexical analyzer whereas YACC generates Code for Syntax analyzer.
Lexical analyzer is build using a tool called LEX. Input is given to LEX and lexical analyzer
is generated.
Lex is a UNIX utility. It is a program generator designed for lexical processing of
character input streams. Lex generates C code for lexical analyzer. It uses the patterns that
match strings in the input and converts the strings to tokens. Lex helps you by taking a set
of descriptions of possible tokens and producing a C routine, which we call a lexical
analyzer. The token descriptions that Lex uses are known as regular expressions.
1.1 Steps in writing LEX Program:
1st Step:
2nd Step:
3rd Step:
4th Step:
Using gedit create a file with extension l. For example: prg1.l
lex prg1.l
cc lex.yy.c –ll
./a.out
1.2 Structure of LEX source program:
{definitions}
%%
{rules}
%%
{user subroutines/code section}
%% is a delimiter to the mark the beginning of the Rule section. The second %% is optional,
but the first is required to mark the beginning of the rules. The definitions and the code
/subroutines are often omitted.
Lex variables
yyin
yyout
Of the type FILE*. This points to the current file being parsed by the lexer.
Of the type FILE*. This points to the location where the output of the lexer
will be written. By default, both yyin and yyout point to standard input and
Dept. of CSE, CIT, Gubbi
Page 1
System Software and Operating System Lab-15CSL67
yytext
yyleng
yylineno
VI Semester CSE
output.
The text of the matched pattern is stored in this variable (char*).
Gives the length of the matched pattern.
Provides current line number information. (May or may not be supported
by the lexer.)
Lex functions
yylex()
yywrap()
yyless(int n)
yymore()
The function that starts the analysis. It is automatically generated by Lex.
This function is called when end of file (or input) is encountered. If this
function returns 1, the parsing stops. So, this can be used to parse multiple
files. Code can be written in the third section, which will allow multiple
files to be parsed. The strategy is to make yyin file pointer (see the
preceding table) point to a different file until all the files are parsed. At the
end, yywrap() can return 1 to indicate end of parsing.
This function can be used to push back all but first „n‟ characters of the
read token.
This function tells the lexer to append the next token to the current token.
1.3 Regular Expressions
It is used to describe the pattern. It is widely used to in lex. It uses meta language. The
character used in this meta language are part of the standard ASCII character set. An
expression is made up of symbols. Normal symbols are characters and numbers, but there are
other symbols that have special meaning in Lex. The following two tables define some of the
symbols used in Lex and give a few typical examples.
Character
A-Z, 0-9, a-z
.
[]
*
+
?
$
{}
\
Dept. of CSE, CIT, Gubbi
Meaning
Characters and numbers that form part of the pattern.
Matches any character except \n.
Used to denote range. Example: A-Z implies all characters from A
to Z.
A character class. Matches any character in the brackets. If the first
character is ^ then it indicates a negation pattern. Example: [abC]
matches either of a, b, and C.
Match zero or more occurrences of the preceding pattern.
Matches one or more occurrences of the preceding pattern.(no
empty string).
Ex: [0-9]+ matches “1”,”111” or “123456” but not an empty string.
Matches zero or one occurrences of the preceding pattern.
Ex: -?[0-9]+ matches a signed number including an optional
leading minus.
Matches end of line as the last character of the pattern.
1) Indicates how many times a pattern can be present. Example:
A{1,3} implies one to three occurrences of A may be present.
2) If they contain name, they refer to a substitution by that name.
Ex: {digit}
Used to escape meta characters. Also used to remove the special
meaning of characters as defined in this table.
Page 2
System Software and Operating System Lab-15CSL67
VI Semester CSE
Ex: \n is a newline character, while “\*” is a literal asterisk.
Negation.
Matches either the preceding regular expression or the following
regular expression.
Ex: cow|sheep|pig matches any of the three words.
Literal meanings of characters. Meta characters hold.
Look ahead. Matches the preceding pattern only if followed by the
succeeding expression. Example: A0/1 matches A0 only if A01 is
the input.
Groups a series of regular expressions together into a new regular
expression.
Ex: (01) represents the character sequence 01. Parentheses are
useful when building up complex patterns with *,+ and |
^
|
"< symbols>"
/
()
Examples of regular expressions
Regular
Meaning
expression
joke[rs]
Matches either jokes or joker.
A{1,2}shis+
Matches AAshis, Ashis, AAshi, Ashi.
Matches zero or one occurrences of A followed by any character
(A[b-e])+
from b to e.
[0-9]
0 or 1 or 2 or………9
[0-9]+
1 or 111 or 12345 or …At least one occurrence of preceding exp
[0-9]*
Empty string (no digits at all) or one or more occurrence.
-?[0-9]+
-1 or +1 or +2 …..
[0.9]*\.[0.9]+
0.0,4.5 or .31415 But won‟t match 0 or 2
Examples of token declarations
Token
number
chars
Blank
Word
Variable
Associated expression
([0-9])+
[A-Za-z]
""
(chars)+
(chars)+(number)*(chars)*( number)*
Dept. of CSE, CIT, Gubbi
Meaning
1 or more occurrences of a digit
Any character
A blank space
1 or more occurrences of chars
Page 3
System Software and Operating System Lab-15CSL67
VI Semester CSE
2. INTRODUCTION TO YACC
YACC provides a general tool for imposing structure on the input to a computer
program. The input specification is a collection of grammar rules. Each rule describes an
allowable structure and gives it a name. YACC prepares a specification of the input process.
YACC generates a function to control the input process. This function is called a parser.
The name is an acronym for “Yet Another Compiler Compiler”. YACC generates the
code for the parser in the C programming language. YACC was developed at AT& T for the
Unix operating system. YACC has also been rewritten for other languages, including Java,
Ada.
The function parser calls the lexical analyzer to pick up the tokens from the input
stream. These tokens are organized according to the input structure rules .The input structure
rule is called as grammar. When one of the rule is recognized, then user code supplied for this
rule ( user code is action) is invoked. Actions have the ability to return values and makes use
of the values of other actions.
2.1 Steps in writing YACC Program:
1st Step:
2nd Step:
3rd Step:
4th Step:
5th Step:
Using gedit editor create a file with extension y. For example: gedit prg1.y
YACC –d prg1.y
lex prg1.l
cc y.tab.c lex.yy.c -ll
/a.out
When we run YACC, it generates a parser in file y.tab.c and also creates an include
file y.tab.h. To obtain tokens, YACC calls yylex. Function yylex has a return type of int, and
returns the token. Values associated with the token are returned by lex in variable yylval.
2.2 Structure of YACC source program:
Basic Specification:
Dept. of CSE, CIT, Gubbi
Page 4
System Software and Operating System Lab-15CSL67
VI Semester CSE
Every YACC specification file consists of three sections. The declarations, Rules (of
grammars), programs. The sections are separated by double percent “%%” marks. The % is
generally used in YACC specification as an escape character.
The general format for the YACC file is very similar to that of the Lex file.
{definitions}
%%
{rules}
%%
{user subroutines}
%% is a delimiter to the mark the beginning of the Rule section.
Definition Section
%union
It defines the Stack type for the Parser. It is a union of various datas/structures/
Objects
%token
These are the terminals returned by the yylex function to the YACC. A token can
also have type associated with it for good type checking and syntax directed
translation. A type of a token can be specified as %token tokenName.
Ex:
%token NAME NUMBER
%type
The type of a non-terminal symbol in the Grammar rule can be specified with
this.The format is %type non-terminal.
%noassoc
Specifies that there is no associatively of a terminal symbol.
%left
Specifies the left associatively of a Terminal Symbol
%right
Specifies the right associatively of a Terminal Symbol.
%start
Specifies the L.H.S non-terminal symbol of a production rule which should be
taken as the starting point of the grammar rules.
%prec
Changes the precedence level associated with a particular rule to that of the
following token name or literal
Rules Section
The rules section simply consists of a list of grammar rules. A grammar rule has the form:
A: BODY
A represents a nonterminal name, the colon and the semicolon are YACC punctuation
and BODY represents names and literals. The names used in the body of a grammar rule may
represent tokens or nonterminal symbols. The literal consists of a character enclosed in single
quotes.
Dept. of CSE, CIT, Gubbi
Page 5
System Software and Operating System Lab-15CSL67
VI Semester CSE
Names representing tokens must be declared as follows in the declaration sections:
%token name1 name2…
Every name not defined in the declarations section is assumed to represent a nonterminal symbol. Every non-terminal symbol must appear on the left side of at least one rule.
Of all the no terminal symbols, one, called the start symbol has a particular importance. The
parser is designed to recognize the start symbol. By default the start symbol is taken to be
the left hand side of the first grammar rule in the rules section.
With each grammar rule, the user may associate actions to be. These actions may return
values, and may obtain the values returned by the previous actions. Lexical analyzer can return
values for tokens, if desired. An action is an arbitrary C statement. Actions are enclosed in curly
braces.
Dept. of CSE, CIT, Gubbi
Page 6
System Software and Operating System Lab-15CSL67
VI Semester CSE
3. INTRODUCTION TO UNIX
Basic UNIX commands
Folder/Directory Commands and Options
Action
Check current Print Working Directory
Return to user's home folder
Up one folder
Make directory
Remove empty directory
Remove directory-recursively
UNIX options & filespec
Pwd
Cd
cd ..
mkdir proj1
rmdir/usr/sam
rm –r
File Listing Commands and Options
Action
List directory tree- recursively
List last access dates of files, with hidden
files
List files by reverse date
List files verbosely by size of file
List files recursively including contents of
other directories
List number of lines in folder
List files with x anywhere in the name
UNIX options & filespec
ls –r
ls -l –a
ls -t -r *.*
ls -l -s *.*
ls -R *.*
wc -l *.xtumlsed -n '$='
ls | grep x
File Manipulation Commands and Options
Action
UNIX options & filespec
touch afilename
Create new(blank)file
Copy old file to new file. -p preserve file
attributes(e.g. ownership and edit dates)-r
copy recursively through directory
structure -a archive, combines the flags-p –
cp old.filenew.file
R and-d
Move old.file(-i interactively flag prompts
mv –i old.file/tmp
before overwriting files)
Remove file(-intention)
rm –i sam.txt
vi file.txt
View a file
Concatenate files
cat file1file2 to standard output.
Counts-lines,-words, and- characters in a
wc -l
file
Dept. of CSE, CIT, Gubbi
Page 7
System Software and Operating System Lab-15CSL67
VI Semester CSE
4. INTRODUCTION TO OPERATING SYSTEMS
Introduction
An Operating System is a program that manages the Computer hardware. It controls
and coordinates the use of the hardware among the various application programs for the
various users.
A Process is a program in execution. As a process executes, it changes state
New: The process is being created
Running: Instructions are being executed
Waiting: The process is waiting for some event to occur
Ready: The process is waiting to be assigned to a process
Terminated : The process has finished execution
Apart from the program code, it includes the current activity represented by
Program Counter,
Contents of Processor registers,
Process Stack which containstemporary data like function parameters, return
addresses and local variables
Data section which contains global variables
Heap for dynamic memory allocation
A Multi-programmed system can have many processes running simultaneously with
the CPU multiplexed among them. By switching the CPU between the processes, the OS
can make the computer more productive. There is Process Scheduler which selects the
process among many processes that are ready, for program execution on the CPU.
Dept. of CSE, CIT, Gubbi
Page 8
System Software and Operating System Lab-15CSL67
VI Semester CSE
Switching the CPU to another process requires performing a state save of the current
process and a state restore of new process, this is Context Switch.
4.1 Scheduling Algorithms
CPU Scheduler can select processes from ready queue based on various scheduling
algorithms. Different scheduling algorithms have different properties, and the choice of a
particular algorithm may favor one class of processes over another. The scheduling criteria
include
CPU utilization:
Throughput: The number of processes that are completed per unit time.
Waiting time: The sum of periods spent waiting in ready queue.
Turnaround time:
The interval between the time of submission of process to the time
of completion.
Response time: The time from submission of a request until the first response is
produced.
The different scheduling algorithms are
FCFS: First Come First Served Scheduling
SJF: Shortest Job First Scheduling
SRTF: Shortest Remaining Time First Scheduling
Priority Scheduling
Round Robin Scheduling
Multilevel Queue Scheduling
Multilevel Feedback Queue Scheduling
4.2 Deadlocks
A process requests resources; and if the resource is not available at that time, the
process enters a waiting state. Sometimes, a waiting process is never able to change state,
because the resource is has requested is held by another process which is also waiting. This
situation is called Deadlock. Deadlock is characterized by four necessary conditions
Mutual Exclusion
Hold and Wait
No Preemption
Circular Wait
Dept. of CSE, CIT, Gubbi
Page 9
System Software and Operating System Lab-15CSL67
VI Semester CSE
Deadlock can be handled in one of these ways,
Deadlock Avoidance
Deadlock Detection and Recover
Shortest remaining time scheduling algorithm:
Shortest remaining time, also known as shortest remaining time first (SRTF), is
a scheduling method that is a preemptive version of shortest job next scheduling. In this
scheduling algorithm, the process with the smallest amount of time remaining until
completion is selected to execute. Since the currently executing process is the one with the
shortest amount of time remaining by definition, and since that time should only reduce as
execution progresses, processes will always run until they complete or a new process is added
that requires a smaller amount of time.
Shortest remaining time is advantageous because short processes are handled very
quickly. The system also requires very little overhead since it only makes a decision when a
process completes or a new process is added, and when a new process is added the algorithm
only needs to compare the currently executing process with the new process, ignoring all
other processes currently waiting to execute.
Like shortest job first, it has the potential for process starvation; long processes may
be held off indefinitely if short processes are continually added.
Round Robin (RR) scheduling algorithm:
Round-robin (RR) is one of the algorithms employed by process and network
schedulers in computing. As the term is generally used, time slices (also known as time
quanta) are assigned to each process in equal portions and in circular order, handling all
processes without priority (also known as cyclic executive). Round-robin scheduling is
simple, easy to implement, and starvation-free. Round-robin scheduling can also be applied
to other scheduling problems, such as data packet scheduling in computer networks. It is an
operating system concept.
The name of the algorithm comes from the round-robin principle known from other
fields, where each person takes an equal share of something in turn.
Banker’s algorithm:
Dept. of CSE, CIT, Gubbi
Page 10
System Software and Operating System Lab-15CSL67
VI Semester CSE
The Banker's algorithm, sometimes referred to as the detection algorithm, is a
resource allocation and deadlock avoidance algorithm developed by Edsger Dijkstra that
tests for safety by simulating the allocation of predetermined maximum possible amounts of
all resources, and then makes an "s-state" check to test for possible deadlock conditions for
all other pending activities, before deciding whether allocation should be allowed to
continue.
The algorithm was developed in the design process for the operating system and
originally described (in Dutch) in EWD108. When a new process enters a system, it must
declare the maximum number of instances of each resource type that it may ever claim;
clearly, that number may not exceed the total number of resources in the system. Also, when
a process gets all its requested resources it must return them in a finite amount of time.
Page replacement algorithms LRU and FIFO:
In a computer operating system that uses paging for virtual memory management,
page replacement algorithms decide which memory pages to page out, sometimes called
swap out, or write to disk, when a page of memory needs to be allocated. Page replacement
happens when a requested page is not in memory (page fault) and a free page cannot be used
to satisfy the allocation, either because there are none, or because the number of free pages is
lower than some threshold.
When the page that was selected for replacement and paged out is referenced again it
has to be paged in (read in from disk), and this involves waiting for I/O completion. This
determines the quality of the page replacement algorithm: the less time waiting for page-ins,
the better the algorithm. A page replacement algorithm looks at the limited information
about accesses to the pages provided by hardware, and tries to guess which pages should be
replaced to minimize the total number of page misses, while balancing this with the costs
(primary storage and processor time) of the algorithm itself. The page replacing problem is a
typical online problem from the competitive analysis perspective in the sense that the
optimal deterministic algorithm is known.
Dept. of CSE, CIT, Gubbi
Page 11
System Software and Operating System Lab-15CSL67
VI Semester CSE
5. INTRODUCTION TO COMPILER DESIGN
A program for a computer must be built by combining these very simple commands into a
program in what is called machine language. Since this is a tedious and error prone process most
programming is, instead, done using a high-level programming language. This language can be very
different from the machine language that the computer can execute, so some means of bridging the
gap is required. This is where the compiler comes in. A compiler translates (or compiles) a program
written in a high-level programming language that is suitable for human programmers into the lowlevel machine language that is required by computers.
The phases of a compiler:
Lexical analysis: This is the initial part of reading and analysing the program text: The text is read
and divided into tokens, each of which corresponds to a symbol in the programming language, e.g., a
variable name, keyword or number.
Syntax analysis: This phase takes the list of tokens produced by the lexical analysis and arranges
these in a tree-structure (called the syntax tree) that reflects the structure of the program. This phase is
often called parsing.
Type checking: This phase analyses the syntax tree to determine if the program violates certain
consistency requirements, e.g., if a variable is used but not declared or if it is used in a context that
does not make sense given the type of the variable, such as trying to use a boolean value as a function
pointer.
Intermediate code generation: The program is translated to a simple machine independent
intermediate language.
Register allocation: The symbolic variable names used in the intermediate code are translated to
numbers, each of which corresponds to a register in the target machine code.
Machine code generation: The intermediate language is translated to assembly language (a textual
representation of machine code) for a specific machine architecture.
Assembly and linking: The assembly-language code is translated into binary representation and
addresses of variables, functions, etc., are determined.
Parsing:
A parser is a compiler or interpreter component that breaks data into smaller
elements for easy translation into another language. A parser takes input in the form of a
sequence of tokens or program instructions and usually builds a data structure in the form of
a parse tree or an abstract syntax tree.
Dept. of CSE, CIT, Gubbi
Page 12
System Software and Operating System Lab-15CSL67
VI Semester CSE
A parser's main purpose is to determine if input data may be derived from the start
symbol of the grammar.
Syntax analyzers follow production rules defined by means of context-free grammar.
The way the production rules are implemented (derivation) divides parsing into two types:
top-down parsing and bottom-up parsing.
Top-Down Parsing:
When the parser starts constructing the parse tree from the start symbol and then tries
to transform the start symbol to the input, it is called top-down parsing.
Recursive descent parsing: It is a common form of top-down parsing. It is called
recursive as it uses recursive procedures to process the input. Recursive descent parsing
suffers from backtracking.
Backtracking: It means, if one derivation of a production fails, the syntax analyzer
restarts the process using different rules of same production. This technique may process
the input string more than once to determine the right production.
Shift Reduce Parsing/Bottom up parsing:
Bottom-up parsing starts with the input symbols and tries to construct the parse tree
up to the start symbol. Bottom up parsing can be defined as an attempt to reduce the input
string „w‟ to the start symbol of a grammar by tracing out the rightmost derivations of „w‟ in
reverse.
Shift-reduce Parsing (Bottom-up Parsing)
Shift-reduce parsing attempts to construct a parse tree for an input string beginning at
the leaves and working up towards the root. In other words, it is a process of “reducing”
(opposite of deriving a symbol using a production rule) a string w to the start symbol of a
Dept. of CSE, CIT, Gubbi
Page 13
System Software and Operating System Lab-15CSL67
VI Semester CSE
grammar. At every (reduction) step, a particular substring matching the RHS of a production
rule is replaced by the symbol on the LHS of the production.
A general form of shift-reduce parsing is LR (scanning from Left to right and using
Right-most derivation in reverse) parsing, which is used in a number of automatic parser
generators like Yacc, Bison, etc.
Intermediate code/ three address code:
Three-address code(often abbreviated to TAC or 3AC) is an intermediate code used
by optimizing compilers to aid in the implementation of code-improving transformations.
Each TAC instruction has at most three operands and is typically a combination of
assignment and a binary operator. For example, t1 = t2 + t3. The name derives from the use
of three operands in these statements even though instructions with fewer operands may
occur.
Since three-address code is used as an intermediate language within compilers, the
operands will most likely not be concrete memory addresses or processor registers, but rather
symbolic addresses that will be translated into actual addresses during register allocation. It is
also not uncommon that operand names are numbered sequentially since three-address code
is typically generated by the compiler.
Example: One solution to the quadratic equation using three address code is as below.
x = (-b + sqrt(b^2 - 4*a*c)) / (2*a)
t1 = b * b
t2 = 4 * a
t3 = t2 * c
t4 = t1 - t3
t5 = sqrt(t4)
t6 = 0 - b
t7 = t5 + t6
t9 = t7 / t8
x = t9
t8 = 2 * a
Dept. of CSE, CIT, Gubbi
Page 14
System Software and Operating System Lab-15CSL67
VI Semester CSE
6. SAMPLE LEX AND YACC PROGRAMS
Example LEX Program
A Simple program:To count the no of a’s in the given string
%{
int c=0;
%}
%%
[a]*
{c++;}
.
;
%%
main()
{
yylex();
printf(“the no of a‟s in the given string : %d”,c);
}
How to run this Program?
$lex filename.l
$cc lex.yy.c –ll
$./a.out
Example YACC Program
A Simple program: To print whether the input string is accepted or not.
%{
#include
%}
% token A B
%%
S:
|A S B
%%
main()
{
Dept. of CSE, CIT, Gubbi
Page 15
System Software and Operating System Lab-15CSL67
VI Semester CSE
printf(“Enter the string\n”);
yyparse();
printf(“given string is accepted”);
}
yyerror()
{
printf(“not accepted”);
exit(0);
}
yylex()
{
int ch;
ch=getchar();
if(ch==‟a‟)
return A;
if(ch==‟b‟)
return B;
if(ch==‟\n‟)
return ch;
}
How to run this program?
$ yacc filename.y
$cc y.tab.c –ll
$./a.out
Enter the string
Aabb
Given string is accepted
Dept. of CSE, CIT, Gubbi
Page 16
System Software and Operating System Lab-15CSL67
VI Semester CSE
7. LAB PROGRAMS
1. a). Write a LEX program to recognize valid arithmetic expression. Identifiers in the
expression could be only integers and operators could be + and *. Count the identifiers
& operators present and print them separately.
%{
int a[]={0,0,0,0},i,valid=1,opnd=0;
%}
%x OPER
%%
[0-9]+
{ BEGIN OPER; opnd++;}
"+"
{ if(valid) { valid=0;i=0;} else ext();}
"-"
{ if(valid) { valid=0;i=1;} else ext();}
"*"
{ if(valid) { valid=0;i=2;} else ext();}
"/"
{ if(valid) { valid=0;i=3;} else ext();}
[a-zA-Z0-9]+
{ opnd++;
if(valid==0)
{
valid=1; a[i]++;
}
else
ext();
}
"\n"
{ if(valid==0)
ext();
else
return 0;
}
.\n
ext();
%%
ext()
{
printf(" Invalid Expression \n");
exit(0);
}
main()
{
printf(" Type the arithmetic Expression \n");
yylex();
printf(" Valid Arithmetic Expression \n");
printf(" No. of Operands/Identifiers : %d \n ",opnd);
printf(" No. of Additions : %d \n No. of Subtractions : %d \n",a[0],a[1]);
printf(" No. of Multiplications : %d \n No. of Divisions : %d \n",a[2],a[3]);
}
Dept. of CSE, CIT, Gubbi
Page 17
System Software and Operating System Lab-15CSL67
VI Semester CSE
Output:
b). Write YACC program to evaluate arithmetic expression involving operators: +, -, *,
and /.
Lex Part
%{
#include "y.tab.h"
extern yylval;
%}
%%
[0-9]+ {yylval=atoi(yytext);return num;}
/* convert the string to
number and send the
value*/
[\+\-\*\/] {return yytext[0];}
[)] {return yytext[0];}
[(] {return yytext[0];}
. {;}
\n {return 0;}
%%
YACC Part
%{
#include
#include
%}
%token num
%left '+' '-'
%left '*' '/'
%%
input:exp {printf("%d\n",$$);exit(0);}
exp:exp'+'exp {$$=$1+$3;}
|exp'-'exp{$$=$1-$3;}
|exp'*'exp{$$=$1*$3;}
Dept. of CSE, CIT, Gubbi
Page 18
System Software and Operating System Lab-15CSL67
VI Semester CSE
|exp'/'exp { if($3==0){printf("Divide by Zero error\n");exit(0);}
else
$$=$1/$3;}
|'('exp')'{$$=$2;}
|num{$$=$1;};
%%
int yyerror()
{
printf("error");
exit(0);
}
int main()
{
printf("Enter an expression:\n");
yyparse();
}
Output:
Dept. of CSE, CIT, Gubbi
Page 19
System Software and Operating System Lab-15CSL67
VI Semester CSE
2. Develop, Implement and Execute a program using YACC tool to recognize all strings
ending with b preceded by n a’s using the grammar an b (note: input n value).
Lex Part
%{
#include "y.tab.h"
%}
%%
a {return A;}
b {return B;}
[\n] return '\n';
%%
YACC Part
%{
#include
#include
%}
%token A B
%%
input:s'\n' {printf("Successful Grammar\n");exit(0);}
s: A s1 B| B
s1: ; | A s1
%%
main()
{
printf("Enter A String\n");
yyparse();
}
int yyerror()
{
printf("Error \n");
exit(0);
}
Output:
Dept. of CSE, CIT, Gubbi
Page 20
System Software and Operating System Lab-15CSL67
VI Semester CSE
3. Design, develop and implement YACC/C program to construct Predictive / LL(1)
Parsing Table for the grammar rules: A aBa , B bB | . Use this table to parse the
sentence: abba$.
#include
#include
#include
void main()
{
char fin[10][20],st[10][20],ft[20][20],fol[20][20]; int a=0,e,i,t,b,c,n,k,l=0,j,s,m,p;
printf("enter the no. of coordinates\n"); scanf("%d",&n);
printf("Enter the productions in a grammar\n");
for(i=0;i64)&&(st[i][j]<91)))
{
for(m=0;m0)
{
while(st[i][j]!=st[a][0])
{
a++;
}
b=0;
while(ft[a][b]!='\0')
{
for(m=0;m64)&&(st[k][j]<91)))
{
for(m=0;m64)&&(st[i][t]<91)))
printf("M[%c,%c]=%s\n",st[i][0],st[i][t],fin[s]);
else
{
b=0;
a=0;
while(st[a][0]!=st[i][3])
{
a++;
}
while(ft[a][b]!='\0')
{
printf("M[%c,%c]=%s\n",st[i][0],ft[a][b],fin[s]);
b++;
}
}
s++;
}
if(st[i][j]=='|')
j++;
}
}
getch();
}
Output:
Dept. of CSE, CIT, Gubbi
Page 25
System Software and Operating System Lab-15CSL67
VI Semester CSE
Design, develop and implement YACC/C program to demonstrate Shift Reduce
Parsing technique for the grammar rules: E E+T | T, T T*F | F, F (E) | id and
parse the sentence: id + id * id.
4.
#include
#include
#include
int k=0,z=0,i=0,j=0,c=0;
char a[16],ac[20],stk[15],act[10];
void check();
void main()
{
puts("GRAMMAR is E->E+E \n E->E*E \n E->(E) \n E->id");
puts("enter input string ");
gets(a);
c=strlen(a);
strcpy(act,"SHIFT->");
puts("stack \t input \t action");
for(k=0,i=0; j
#include
#include
char op[2],arg1[5],arg2[5],result[5];
void main()
{
FILE *fp1,*fp2;
fp1=fopen("inpu
t.txt","r");
fp2=fopen("outp
ut.txt","w");
while(!feof(fp1))
{
fscanf(fp1,"%s%s%s%s",result,arg1,op,arg2);
if(strcmp(op,"+")==0)
{
fprintf(fp2,"\nMOV R0,%s",arg1);
fprintf(fp2,"\nADD R0,%s",arg2);
fprintf(fp2,"\nMOV %s,R0",result);
}
if(strcmp(op,"*")==0)
{
fprintf(fp2,"\nMOV R0,%s",arg1);
fprintf(fp2,"\nMUL R0,%s",arg2);
fprintf(fp2,"\nMOV %s,R0",result);
}
if(strcmp(op,"-")==0)
{
fprintf(fp2,"\nMOV R0,%s",arg1);
fprintf(fp2,"\nSUB R0,%s",arg2);
fprintf(fp2,"\nMOV %s,R0",result);
}
if(strcmp(op,"/")==0)
{
fprintf(fp2,"\nMOV R0,%s",arg1);
fprintf(fp2,"\nDIV R0,%s",arg2);
fprintf(fp2,"\nMOV %s,R0",result);
}
if(strcmp(op,"=")==0)
{
fprintf(fp2,"\nMOV R0,%s",arg1);
Dept. of CSE, CIT, Gubbi
Page 29
System Software and Operating System Lab-15CSL67
VI Semester CSE
fprintf(fp2,"\nMOV %s,R0",result);
}
}
fclose(fp1);
fclose(fp2);
getch();
}
Output:
Dept. of CSE, CIT, Gubbi
Page 30
System Software and Operating System Lab-15CSL67
VI Semester CSE
6. a) Write a LEX program to eliminate comment lines in a C program and copy the
resulting program into a separate file.
%{
#include
int sl=0;
int ml=0;
%}
%%
"/*"[a-zA-Z0-9' '\t\n]+"*/" ml++;
"//".*
sl++;
%%
main()
{
yyin=fopen("f1.c","r");
yyout=fopen("f2.c","w");
yylex();
fclose(yyin);
fclose(yyout);
printf("\n Number of single line comments are = %d\n",sl);
printf("\nNumber of multiline comments are =%d\n",ml);
}
Output:
Dept. of CSE, CIT, Gubbi
Page 31
System Software and Operating System Lab-15CSL67
VI Semester CSE
b). Write YACC program to recognize valid identifier, operators and keywords in the
given text (C program) file.
Lex File
%{
#include
#include "y.tab.h"
extern yylval;
%}
%%
[ \t] ;
[+|-|*|/|=|<|>] {printf("operator is %s\n",yytext);return OP;}
[0-9]+ {yylval = atoi(yytext); printf("numbers is %d\n",yylval); return DIGIT;}
int|char|bool|float|void|for|do|while|if|else|return|void {printf("keyword
is
%s\n",yytext);return KEY;}
[a-zA-Z0-9]+ {printf("identifier is %s\n",yytext);return ID;}
.;
%%
Yacc File
%{
#include
#include
int id=0, dig=0, key=0, op=0;
%}
%token DIGIT ID KEY OP
%%
input:
DIGIT input { dig++; }
| ID input { id++; }
| KEY input { key++; }
| OP input {op++;}
| DIGIT { dig++; }
| ID { id++; }
| KEY { key++; }
| OP { op++;}
;
%%
#include
extern int yylex();
extern int yyparse();
extern FILE *yyin;
main() {
FILE *myfile = fopen("sam_input.c", "r");
if (!myfile) {
printf("I can't open sam_input.c!");
Dept. of CSE, CIT, Gubbi
Page 32
System Software and Operating System Lab-15CSL67
VI Semester CSE
return -1;
}
yyin = myfile;
do {
yyparse();
} while (!feof(yyin));
printf("numbers = %d\nKeywords = %d\nIdentifiers = %d\noperators =
%d\n",
dig, key,id, op);
}
void yyerror() {
printf("EEK, parse error! Message: ");
exit(-1);
}
Output:
Input file
Dept. of CSE, CIT, Gubbi
Page 33
System Software and Operating System Lab-15CSL67
Dept. of CSE, CIT, Gubbi
VI Semester CSE
Page 34
System Software and Operating System Lab-15CSL67
VI Semester CSE
7. Design, develop and implement a C/C++/Java program to simulate the working of
Shortest remaining time and Round Robin (RR) scheduling algorithms. Experiment
with different quantum sizes for RR algorithm.
#include
struct proc
{
int id;
int arrival;
int burst;
int rem;
int wait;
int finish;
int turnaround;
float ratio;
}process[10]; //structure to hold the process information
struct proc temp;
int no;
int chkprocess(int);
int nextprocess();
void roundrobin(int, int, int[], int[]);
void srtf(int);
main()
{
int n,tq,choice;
int bt[10],st[10],i,j,k;
for(; ;)
{
printf("Enter the choice \n");
printf(" 1. Round Robin\n 2. SRT\n 3. Exit \n");
scanf("%d",&choice);
switch(choice)
{
case 1:
printf("Round Robin scheduling algorithm\n");
printf("Enter number of processes:\n");
scanf("%d",&n);
printf("Enter burst time for sequences:");
for(i=0;itq) // when service time of a process greater than time
//quantum then time
st[i]=st[i]-tq; //quantum value subtracted from service time
else
if(st[i]>=0)
{
temp1=st[i];
// temp1 stores the service time of a process
st[i]=0;
// making service time equals 0
}
sq=sq+temp1;
// utilizing temp1 value to calculate turnaround
time
tat[i]=sq;
// turn around time
} //end of for
if(n==count)
// it indicates all processes have completed their
task
because the count value
break;
// incremented when service time equals 0
} //end of while
for(i=0;i process[j].arrival)
// sort arrival time of a process
{
temp = process[i];
process[i] = process[j];
process[j] = temp;
}
}
}
no = 0;
j = 1;
while(chkprocess(n) == 1)
{
if(process[no + 1].arrival == time)
{
while(process[no+1].arrival==time)
no++;
if(process[j].rem==0)
process[j].finish=time;
j = nextprocess();
}
if(process[j].rem != 0)
// to calculate the waiting time of a
process
{
process[j].rem--;
for(i = 1; i <= no; i++)
{
if(i != j && process[i].rem != 0)
process[i].wait++;
}
}
else
{
process[j].finish = time;
j=nextprocess();
time--;
k=j;
}
time++;
}
process[k].finish = time;
Dept. of CSE, CIT, Gubbi
Page 38
System Software and Operating System Lab-15CSL67
VI Semester CSE
printf("\n\n\t\t\t---SHORTEST REMAINING TIME FIRST---");
printf("\n\n Process Arrival Burst Waiting Finishing turnaround Tr/Tb\n");
printf("%5s %9s %7s %10s %8s %9s\n\n", "id", "time", "time", "time",
"time", "time");
for(i = 1; i <= n; i++)
{
process[i].turnaround = process[i].wait + process[i].burst; // calc of
turnaround process[i].ratio = (float)process[i].turnaround /
(float)process[i].burst;
printf("%5d %8d %7d %8d %10d %9d %10.1f ", process[i].id,
process[i].arrival, process[i].burst, process[i].wait, process[i].finish,
process[i].turnaround, process[i].ratio);
tavg=tavg+ process[i].turnaround; //summation of turnaround
time
wavg=wavg+process[i].wait;
// summation of waiting time
printf("\n\n");
}
tavg=tavg/n;
// average turnaround time
wavg=wavg/n; // average wait time
printf("tavg=%f\t wavg=%f\n",tavg,wavg); }// end of srtf
Output:
Enter the choice
1) Round Robin 2) SRT
3) Exit
1
Round Robin scheduling algorithm
**********************************
Enter number of processes:3
Enter burst time for sequences:24
3
3
Enter time quantum:4
Process_no Burst time
Wait time Turnaround time
1
24
6
30
2
3
4
7
3
3
7
10
Avg wait time is 5.666667
Avg turnaround time is 15.666667
Enter the choice
1) Round Robin 2) SRT
3) Exit
2
---SHORTEST REMAINING TIME NEXT--Enter the number of processes: 4
Enter the arrival time for process 1: 0
Enter the burst time for process 1: 8
Dept. of CSE, CIT, Gubbi
Page 39
System Software and Operating System Lab-15CSL67
VI Semester CSE
Enter the arrival time for process 2: 1
Enter the burst time for process 2: 4
Enter the arrival time for process 3: 2
Enter the burst time for process 3: 9
Enter the arrival time for process 4: 3
Enter the burst time for process 4: 5
1
24
6
30
2
3
4
7
3
3
7
10
---SHORTEST REMAINING TIME FIRST--Enter the number of processes: 4
Enter the arrival time for process 1: 0
Enter the burst time for process 1: 8
Enter the arrival time for process 2: 1
Enter the burst time for process 2: 4
Enter the arrival time for process 3: 2
Enter the burst time for process 3: 9
Enter the arrival time for process 4: 3
Enter the burst time for process 4: 5
---SHORTEST REMAINING TIME NEXT--Process Arrival Burst
id
time time
1
0
8
2
1
4
3
2
9
4
3
5
Waiting Finishing turnaround Tr/Tb
time time time time
9
17
17
2.1
0
5
4
1.0
15
26
24
2.7
2
10
7
1.4
tavg=13.000000
wavg=6.500000
Using OpenMP
Dept. of CSE, CIT, Gubbi
Page 40
System Software and Operating System Lab-15CSL67
VI Semester CSE
8. Design, develop and implement a C/C++/Java program to implement Banker’s
algorithm. Assume suitable input required to demonstrate the results.
#include
#include
int main()
{
int Max[10][10], need[10][10], alloc[10][10], avail[10], completed[10],
safeSequence[10];
int p, r, i, j, process, count;
count = 0;
printf("Enter the no of processes : ");
scanf("%d", &p);
for(i = 0; i< p; i++)
completed[i] = 0;
printf("\n\nEnter the no of resources : ");
scanf("%d", &r);
printf("\n\nEnter the Max Matrix for each process : ");
for(i = 0; i < p; i++)
{
printf("\nFor process %d : ", i + 1);
for(j = 0; j < r; j++)
scanf("%d", &Max[i][j]);
}
printf("\n\nEnter the allocation for each process : ");
for(i = 0; i < p; i++)
{
printf("\nFor process %d : ",i + 1);
for(j = 0; j < r; j++)
scanf("%d", &alloc[i][j]);
}
printf("\n\nEnter the Available Resources : ");
for(i = 0; i < r; i++)
scanf("%d", &avail[i]);
for(i = 0; i < p; i++)
for(j = 0; j < r; j++)
need[i][j] = Max[i][j] - alloc[i][j];
do
{
printf("\n Max matrix:\tAllocation matrix:\n");
for(i = 0; i < p; i++)
{
for( j = 0; j < r; j++)
printf("%d ", Max[i][j]);
printf("\t\t");
for( j = 0; j < r; j++)
printf("%d ", alloc[i][j]);
printf("\n");
Dept. of CSE, CIT, Gubbi
Page 41
System Software and Operating System Lab-15CSL67
VI Semester CSE
}
process = -1;
for(i = 0; i < p; i++)
{
if(completed[i] == 0)//if not completed
{
process = i ;
for(j = 0; j < r; j++)
{
if(avail[j] < need[i][j])
{
process = -1;
break;
}
}
}
if(process != -1)
break;
}
if(process != -1)
{
printf("\nProcess %d runs to completion!", process + 1);
safeSequence[count] = process + 1;
count++;
for(j = 0; j < r; j++)
{
avail[j] += alloc[process][j];
alloc[process][j] = 0;
Max[process][j] = 0;
completed[process] = 1;
}
}
}
while(count != p && process != -1);
if(count == p)
{
printf("\nThe system is in a safe state!!\n");
printf("Safe Sequence : < ");
for( i = 0; i < p; i++)
printf("%d ", safeSequence[i]);
printf(">\n");
}
else
printf("\nThe system is in an unsafe state!!");
}
Dept. of CSE, CIT, Gubbi
Page 42
System Software and Operating System Lab-15CSL67
VI Semester CSE
Output:
Enter the no of processes : 5
Enter the no of resources : 3
Enter the Max Matrix for each process :
For process 1 : 7
5
3
For process 2 : 3
2
2
For process 3 : 7
0
2
For process 4 : 2
2
2
For process 5 : 4
3
3
Enter the allocation for each process :
For process 1 : 0
1
0
For process 2 : 2
0
0
For process 3 : 3
0
2
For process 4 : 2
1
1
For process 5 : 0
0
2
Enter the Available Resources : 3
3
2
Max matrix: Allocation matrix:
753
0 10
322
2 00
702
3 02
222
2 11
433
0 02
Process 2 runs to completion!
Max matrix: Allocation matrix:
753
0 10
000
0 00
Dept. of CSE, CIT, Gubbi
Page 43
System Software and Operating System Lab-15CSL67
702
222
3 02
2 11
433
002
VI Semester CSE
Process 3 runs to completion!
Max matrix: Allocation matrix:
753
010
000
000
000
000
222
211
433
002
Process 4 runs to completion!
Max matrix: Allocation matrix:
753
010
000
000
000
000
000
000
433
002
Process 1 runs to completion!
Max matrix: Allocation matrix:
000
000
000
000
000
000
000
000
433
002
Process 5 runs to completion!
The system is in a safe state!!
Safe Sequence: < 2 3 4 1 5 >
Dept. of CSE, CIT, Gubbi
Page 44
System Software and Operating System Lab-15CSL67
VI Semester CSE
9. Design, develop and implement a C/C++/Java program to implement page
replacement algorithms LRU and FIFO. Assume suitable input required to demonstrate
the results.
#include
#include
void FIFO(char [ ],char [ ],int,int);
void lru(char [ ],char [ ],int,int);
void opt(char [ ],char [ ],int,int);
int main()
{
int ch,YN=1,i,l,f;
char F[10],s[25];
printf("\n\n\tEnter the no of
empty frames: "); scanf("%d",&f);
printf("\n\n\tEnter the length of the string: ");
scanf("%d",&l);
printf("\n\n\tEnter the string: ");
scanf("%s",s);
for(i=0;i
void main()
{
char operator;
float num1, num2, result;
printf("Simulation of a Simple Calculator\n");
printf("*********************************\n");
printf("Enter two numbers \n"); scanf("%f %f", &num1,&num2);
fflush(stdin);
printf("Enter the operator [+,-,*,/] \n");
scanf("%s", &operator);
switch(operator)
{
case '+': result = num1 + num2;
break;
case '-': result = num1 - num2;
break;
case '*': result = num1 * num2;
break;
case '/': result = num1 / num2;
break;
default : printf("Error in operationn");
break;
}
printf("\n %5.2f %c %5.2f = %5.2f\n", num1, operator, num2, result);
}
Output:
Simulation of a Simple Calculator
*********************************
Enter two numbers
2
3
Enter the operator [+,-,*,/]
+
2.00 + 3.00 = 5.00
b). Design, develop and implement a C/C++/Java program to simulate page replacement
technique.
#include
int n,nf;
int in[100];
int p[50];
int hit=0;
int i,j,k;
Dept. of CSE, CIT, Gubbi
Page 49
System Software and Operating System Lab-15CSL67
VI Semester CSE
int pgfaultcnt=0;
void getData()
{
printf("\nEnter length of page reference sequence:");
scanf("%d",&n);
printf("\nEnter the page reference sequence:");
for(i=0; imax)
{
max=near[j];
repindex=j;
}
}
p[repindex]=in[i];
pgfaultcnt++;
dispPages();
}
else
printf("No page fault");
}
dispPgFaultCnt();
}
void lru()
{
initialize();
int least[50];
for(i=0; i=0; k--)
{
Dept. of CSE, CIT, Gubbi
Page 52
System Software and Operating System Lab-15CSL67
VI Semester CSE
if(pg==in[k])
{
least[j]=k;
found=1;
break;
}
else
found=0;
}
if(!found)
least[j]=-9999;
}
int min=9999;
int repindex;
for(j=0; j
Source Exif Data:
File Type : PDF
File Type Extension : pdf
MIME Type : application/pdf
PDF Version : 1.5
Linearized : No
Page Count : 65
EXIF Metadata provided by EXIF.tools