A simple shell (command interpreter) #define TRUE 1! dec.docx

A simple shell (command interpreter)
#define TRUE 1!
/* declare cmd, params, envp, stat, prompt, readcmd */!
!
while (TRUE) { ! !!!/* repeat forever */!
!prompt(); ! !!!!/* display prompt */
!readcmd(cmd, params); /* read input from terminal*/!
!if (fork() != 0) {! !/* fork child process */!
! !/* parent code */!
! !waitpid(-1, &stat, 0); ! !/* wait for child */!
!} else {!
! !/* child code */!
! !execve(cmd, params, envp);!/* execute command */!
!}!
}!
A simple shell (command interpreter)

#define TRUE 1!
/* declare cmd, params, envp, stat, prompt, readcmd */!
!
while (TRUE) { ! !!!/* repeat forever */!
!prompt(); ! !!!!/* display prompt */
!readcmd(cmd, params); /* read input from terminal*/!
!if (fork() != 0) {! !/* fork child process */!
! !/* parent code */!
! !waitpid(
-
1, &stat, 0); ! !/* wait for child */!
!} else {!
! !/* child code */!

! !execve(cmd, params, envp);!/* execute command */!
!}!
}!
UNIT V
Unit IV 2
Running Head: UNIT V
Unit V 1
Unit V: Methodology
I.M. Student
MBA 5652 – Research Methods
9/16/2010

Unit V: Methodology
Method
The research that is proposed for this study will be
developed through a mixed methodology in which a survey
instrument is used to define frequencies within play of online
games specifically focusing on World of Warcraft and Second
Life. Case studies will then be developed through discussions
with individuals who log in long hours of play, providing for a
qualitative element to put the quantitative results into context
with experience. The research study will provide for
development of the understanding of what happens as it is put
into context with how it is experienced.
Participants
Participants in the study will be gathered through
invitations sent in game that will lead players to a website
through which they can take the survey instrument. In addition,
players will be selected for interviews in order to create case
studies for the research study. A goal of 150 players of online
games for the research survey and ten individuals for the
interview portion of the study will be set.
Research Design
The research study will be designed through a mixed
methodology of quantitative and qualitative study methods. The
quantitative study will be designed through using a survey
instrument that asks questions about demographics, play, and
relative questions about length of play. In addition, an
exploration of the players and their avatars will be conducted
through the survey instrument. The information will be put into
a spread sheet from which the sums of and averages will be put
through SPSS software in order to find frequencies between the
variables. The quantitative study will provide a backdrop for the
case studies that will explore the experience of online gaming

and the identity as it is created through the ideal self and
possibly leading to addiction.
The qualitative portion of the study will consist of two or
three case studies that are developed from interviews with ten
different individuals. The case studies will provide context for
the quantitative study, the development of experiential
revelation explaining much of the information that is gathered
through frequencies. The information from the interviews will
also be coded in order to find commonalities within the data
that can be assessed for determining the more commonly
experienced concepts of playing online games in relationship to
identity and addiction.
Instrumentation
The instrument that will be used for the quantitative
portion of the study will be a series of questions that move from
demographic information to game play inquires, and then to
personal information regarding the nature of play. Most of the
questions will be designed for the dependent variables will have
answers given similar to that of a five point Likert scale with 1
being highly dissatisfied, 2 being dissatisfied, 3 being neutral, 4
being satisfied, and 5 being very satisfied. This instrument has
been designed by the researcher and will be found in Appendix
1. The second list of questions is intended for the interviews
within the qualitative portion of the study and will be found in
Appendix 2.
Data Collection Plan
Data for the quantitative survey will be collected from
invitations sent to players of World of Warcraft and Second
Life who will be directed to a website that has been developed
to allow for conducting the survey. The information will be
confidential and provide for the development of a spreadsheet
that can be used to create sums and averages that can be
translated into frequencies through the use of SPSS software.
The case studies will be collected through interviews through
which observation and recordings of the interviews will supply
data of commonalities between participants. In addition, two to

three stories will be developed into case studies.
Proposed Analysis of the Data
Variables
Dependent Variables
The dependent variables that will be used in analyzing the
data will include amount of time spent gaming, number of
avatars used, and level of satisfaction for the ideal self through
the avatar. Additional dependent variables may emerge through
the examination of the data.
Independent Variables
There will be a number of independent variables upon
which the research will develop. Gender, sex, geographic
location, and age are some of the independent variables that will
be used in the analysis. In addition, marital status, parental
status and socio-economic status may be used to help define
some of the issues present.
Validity
Criterion Validity
The criterion validity will depend on the measures that
associate time played in game to addiction. The development of
the addictive nature of gaming will be predicted to be
associated with the amount of time spent in the game
environment. Additionally, the time played in game will be
associated to the marital and parental status of the player,
providing deeper context for who is addicted and who engages
in recreational play.
Construct Validity
The construct validity will be based on defining the nature
of addiction and applying it to game play online. Addiction is
highly complex and can be applied to chemical alterations in the
brain when behavior or ingestion of a substance creates a sense
of satisfaction that leads to abnormal levels of craving. The
word addiction comes from the Latin addicere which means to
bind (Hanson, Venturelli, & Fleckenstein, 2009). In this case,
the validity of the data as it relates to addiction will be in
showing that the player is bound to the game in such a way that

they have difficulty disengaging from it even when real life
aspects of their life require disengaging.
Summary
The methodology of this research proposal is mixed with
both quantitative and qualitative methods of inquiry. The data
will be analyzed through SPSS software for frequencies from
the survey instrument, as well as the qualitative data analyzed
through codifying and placing the information in to a grid to
analyze emerging themes. Participants will come from the
gaming world, using internet technologies to facilitate the use
of the survey instrument. Dependent variables will be
demographic information while the independent variables will
be based on game play and family dynamics. Validity will come
from both assumptions about addiction and the construct of
addiction.
References
Hanson, G., Venturelli, P. J., & Fleckenstein, A. E. (2009).
Drugs and society. Sudbury, Mass: Jones and Bartlett
Publishers.
intmath.h
/*
* The "intmath.h" header defines the following five integer
arithmetic
* functions:

* int add(int x, int y) - returns the sum of x and y
* int subtract(int x, int y) - returns the subtraction of y from x
* int divide(int n, int d) - returns the integer division of n by d
* int modulo(int n, int d) - returns the remainder when n is
divided by d
* int division(int n, int d, int *r) - returns the integer division
of n by d
* and uses r to record the remainder
*
* Implementations of these functions check for overflow of the
range of
* integers as described below.
*
* Implementors of these functions can only use the built-in
arithmetic
* operators ++, -- and unary - negation.
*/
#ifndef _INTMATH_H /* check if "intmath.h" is already
included */
#define _INTMATH_H /* it is not included; define it */
/*
* int add(x, y)
*
* This function returns the sum of two integers (x and y) -
adding y to x.
*
* The function checks for integer overflow. If the result of the
addition of
* the two integers would exceed the defined range for integers
then the value
* of errno is set to ERANGE and the function returns -1.
*
* It is the responsibility of users of this function to test for
errno

* correctly and distinguish between the two cases: (1) where -1
is the valid
* result of the sum of two integers, and (2) when integer
overflow would have
* occurred.
* See: http://man7.org/linux/man-pages/man3/errno.3.html for
information on
* errno
*
* Parameters:
* x - the integer to add y to
* y - the integer to add to x
* Return:
* the result of adding y to x
*/
int add(int x, int y);
/*
* int subtract(int x, int y)
*
* This function returns the difference between two integers (x
and y) - the
* result of subtracting y from x.
*
* The function checks for integer overflow. If the result of the
subtraction of
* y from x would exceed the defined range for integers then the
value
* of errno is set to ERANGE and the function returns -1.
*
errno
is the valid
* result of the subtraction of y from x, and (2) when integer
overflow would

* have occurred.
information on
*
* Parameters:
* x - the integer subtract y from
* y - the integer to subtract from x
* Return:
* the result of subtracting y from x
*/
int subtract(int x, int y);
/*
* int divide(int n, int d)
*
* This function returns the result of integer division of the
numerator (n) by
* the denominator (d).
*
* The function checks for division by 0. If d is 0 then the
function
* returns -1 and errno is set to EDOM.
* There is also one case when the division can cause integer
* overflow. In which case, the function returns -1 and errno is
set to ERANGE.
*
errno
is the valid
* result of the division of n by d, and (2) when division by 0 or
* integer overflow would have occurred.
information on
*
* Parameters:

* n - the numerator of integer division
* d - the denominator of integer division
* Return:
* the result of integer division of n by d
*/
int divide(int n, int d);
/*
* int modulo(int n, int d)
*
* This function returns the remainder of integer after division
of the
* numerator (n) by the denominator (d).
*
function
* returns 0 and errno is set to EDOM.
* overflow. In which case, the function returns 0 and errno is
set to ERANGE.
*
errno
* correctly and distinguish between the two cases: (1) where 0
is the valid
* result of n modulo d, and (2) when division by 0 or integer
overflow would
* have occurred.
information on
*
* Parameters:
* Return:
* the remainder after integer division of n by d

*/
int modulo(int n, int d);
/*
* int division(int n, int d, int *r)
*
* This function returns the result of integer division of the
numerator (n) by
* the denominator (d). In addition, it uses r to record the
remainder of the
* division.
*
function
* returns -1, errno is set to EDOM and *r will be 0.
* overflow. In which case the function returns -1, errno is set
to ERANGE and
* *r will be 0.
*
errno
is the valid
* result of the division of n by d, and (2) when division by 0 or
* integer overflow would have occurred.
information on
*
* Parameters:
* r - the address of integer to record the remainder after
integer division
* of n by d
* Return:

* the result ofinteger division of n by d
*/
int division(int n, int d, int *r);
#endif /* _INTMATH_H */
utils.h
/*
* The "utils.h" header defines the following three utility
functions:
* int getaline(char *linebuf, int bufsize) - read a line of user
input into
* the buffer linebuf
* int split(char *s, int start, char sep, char **substrings, int
max) - split
* a string at the separator character sep into at most max
substrings,
* starting at position start
* int trim(char *s, char c) - trim a string of leading and trailing
sequences
* of the character c, returning the position of the first non-c
character
*
* Implementors of these functions should only use the C library
function
* getchar.
*/
#ifndef _UTILS_H /* check if "utils.h" is already included
*/
#define _UTILS_H /* it is not included; define it */
/*
* int getaline(char* linebuf, int bufsize)
*

* Read a line of user input from stdin into the buffer linebuf a
character at
* a time.
*
* After successful execution of the function, linebuf will
contain up to
* bufsize - 1 characters from user input and will be terminated
by the '0'
* character. That is, linebuf can be treated as a string of up to
busize -1
* characters not including the terminator character. The buffer
must NOT
* contain the end of line character ('n').
*
* The library function getchar can be used to read a character
at a time from
* stdin.
*
* Parameters:
* linebuf - the buffer to fill with characters from the stdin
stream. linebuf
* is modified by this function.
* bufsize - the size of the linebuf buffer
* Return:
* The number of characters read from user input, -1 if there is
an error. If
* linebuf is filled, the number returned will be bufsize - 1 and
there may be
* more user input. If the number returned is 0, there was in
effect no
* user input (e.g. the only character entered was the new line
character)
*/
int getaline(char* linebuf, int bufsize);
/*

* int split(char *s, int start, char sep, char **substrings, int
max)
*
* Split a string, s, into at most max substrings at the given
separator
* character. The substrings array is used to hold pointers to the
* resulting substrings of s. If s does not contain the separator
character then
* a pointer to the single string s will be in the substrings array.
Unused
* elements of the substrings buffer will be set to NULL.
*
* If s contains sequences of more than one separator between
sequences of
* non-separator characters, this function will terminate a
substring at the
* first separator and skip to the next non-separator character to
start the
* next substring. This function does *not* treat sequences of
leading or
* trailing separator characters as special cases. This means
that, after
* calling split, the first and/or last elements of the substrings
array may
* point to the empty string. For example, for the following
inputs:
* char s[]: "--ab--c--"
* int start: 0
* char sep: '-'
* int max: 4
* The substrings buffer will have points to the following
strings:
* { "", "ab", "c", "" }
*
* Other variations of the input string can result in empty
strings at the

* beginning and/or end of the substrings buffer.
*
* To skip leading and trailing separator characters, use trim
before calling
* split. If trim is used before split, and the return value of trim
is used for
* the start value of split, this function will correctly return 0
for a string
* s that only contains separator characters.
*
* Parameters:
* s - the input string. This function may modify s. There is no
copying of
* characters.
* start - the position in s to start the search for separator
characters. The
* first substring will start from this position in s. If start is
less
* than 0, the number of substrings will be 0.
* sep - the character at which substrings should be created
* substrings - the array to populate with pointers to substrings
of s.
* substrings is modified by this function. Neither characters
nor strings
* are copied to substrings. The elements of substrings are
simply pointers
* to substrings of s. If there are less than max substrings,
then the
* remaining elements of the substrings buffer will be set to
NULL.
* max - the maximum number of substrings required. This
should be less than
* or equal to the size of the substrings buffer.
* It is possible for s to contain more than max substrings, in
* which case the final pointer in the substrings buffer will
point to a

* substring that contains one or more separator characters.
* Return:
* the number of pointers to strings in substrings. If s
contains at
* least one non-separator character and max is at least 1, the
number
* of substrings will be at least 1. If the number of
* substrings is less than max, then the elements of
substrings from
* number to max - 1 will be NULL.
*/
int split(char *s, int start, char sep, char **substrings, int max);
/*
* int trim(char *s, char c)
*
* Trim the input string of leading and trailing sequences of the
specified
* character c. The return value is the position of the first
character in s
* that is not c.
*
* Parameters:
* s - the input string. s may be modified by this function, there
is no
* copying of characters.
* c - the character to trim from the beginning and end of s
* Return:
* the position of the first character in s that is not c. -1 if s
* contains no other character than c (not including the
terminator
* character).
*/
int trim(char *s, char c);

#endif /* _UTILS_H */
1. Aim
The aim of this assignment is for you to gain some practice in C
programming, to use C libraries and system calls, and to
demonstrate your understanding of C and how to program to a
defined interface.
2. Learning/skills outcomes
· C programming skills
· Programming to defined interfaces
· Formulate problems and identify suitable approaches to
solving them
· Cognitive/intellectual skills and self management (see
graduate skills framework)
3. Specification
This assignment has three parts:
1. Write a library of simple arithmetic functions (4 marks)
2. Write a library of utilities to read and process user input (8
marks)
3. Write a simple command line shell (8 marks)
Note we will test your solution programmatically on MINIX. It
is very important that you follow the rules below for the form of
your solutions and their submission. For example, do not
deviate from the file names specified. If you do not adhere to
the rules, you will loose marks even if your solution is logically
correct. An important purpose of this assignment is for you to
demonstrate that you can understand an interface definition and
program to that definition. It is also important that your code
executes correctly on MINIX.
You will also have to test your solutions yourself. We will not
mark these tests and they should not be submitted. The files that
you submit are:

· intmath.h - unmodified, provided for you
· intmath.c - your implementation of the functions defined
in intmath.h
· utils.h - unmodified, provided for you
· utils.c - your implementation of the functions defined
in utils.h
· myshell.c - your implemenation of a simple shel that uses the
functions defined in utils.h
In intmath.c, utils.c and myshell.c you may find it useful to
define and implement additional "helper" functions additional
that are not defined in the header files. That is OK. It is up to
you how you organise your solution provided you implement the
functions defined in the header files and the simple shell
program that uses the functions defined in utils.h.
Part 1 - Library of simple arithmetic functions
In this part you will implement the following four simple
arithmetic functions:
int add(int x, int y)
adding x to y and returning the result
int subtract(int x, int y)
subtracting y from x and returning the result
int divide(int n, int d)
integer division of the numerator (dividend) n by the
denominator (divisor) d and returning the result
int modulo(int n, int d)
denominator (divisor) d and returning the remainder
int division(int n, int d, int &r)
denominator (divisor) d, returning the result and recording the
remainder on r
To get full marks for this part you must follow the following
rules. Any deviation from the rules could result in a mark of 0
for this part.
Rules for part 1
1. The functions are defined in intmath.h. The comments to each

function define the contract between yourself and the user of
these functions. Your implementations must satisfy the contract.
For example, you must detect and signal integer overflow using
the ERANGE value for errno. Division by zero is a domain
error, which you must signal with the EDOM errno.
2. You must implement the functions in a separate intmath.c file
that includes intmath.h.
3. intmath.c must not have a main function.
4. You can only use the ++ and -- unary increment and
decrement operators in your calculations. That is, you must
not use +, -, / or % in any of your calculations. You can use - as
a unary operator to negate a number.
To emphasise, the following are allowed in your implementation
of the arithmetic functions:
x++ x-- --x ++x -x
No other built-in arithmetic operators are allowed. That is, the
following are forbidden:
x - y x + y x / y x % y x * y
You may use the full range of built-in arithmetic operators to
test your solution. In fact, you will almost certainly have to use
all the operators to test your solution (with the possible
exception of multiplication).
Hints
· You can avoid code duplication in this task. E.g. think about
how to use subtract for certain inputs to add and how to write
some functions in terms of others.
· Be particularly careful when INT_MIN is the numerator or
denominator in division.
Part 1 deliverables
The deliverables for part 1 are the files intmath.h and intmath.c
Plan your time and do not spend too long on this part. Parts 2
and 3 do not depend on it. However, you should find it easier to
approach the other parts if you complete this part.
Part 2 - Library of user input utils
In this part you will implement the following three utility
functions:

int getaline(char* linebuf, int bufsize)
to read a line of user input from stdin into the character
buffer linebuf. After execution, the function should return the
count of characters read into the buffer and linebuf should
represent a string, terminated with the null character ('0'). The
returned count does not include the null character. bufsize is the
size of linebuf. Therefore, the returned count will be at
most bufsize - 1
int split(char *s, int start, char sep, char **substrings, int max)
to split the null-terminated input string s into at
most max substrings. The string should be split at each
occurrence of the sep character until at most max substrings are
found. The first substring should start at position start (which
may be 0). The use of a start position allows for "pre-
processing" of s (e.g. to ignore leading characters - see trim).
After execution, the function should return the number of
substrings identified. The input string s will now be a buffer of
null-terminated substrings. Each element of the substrings array
will be a pointer to the start of a substring in s up
to max substrings. If there are less than max substrings, the
unused elements at the end of substrings should be set to NULL.
When splitting the input string, multiple consecutive
occurrences of the sep character within the string (as opposed to
at the beginning or end of the string) should be ignored. It is
possible for there to be more thanmax substrings in s, in which
case the final string in the substrings array will contain
separator characters.
int trim(char *s, char c)
to trim the null-terminated input string s (removing leading and
trailing runs of the specified character, c). This function returns
the position of the first character that is not the specified
character in string s and terminates the string s after the last
character that is not the specified character. In effect, trim
allows the user of the function to skip a sequence of leading
characters at the start of s and truncates s at the first occurrence
of a trailing sequence of 1 or more of the specified

character(s). s is modified as a result. The string from the
returned start value may contain the specified character but
there will leading or trailing sequences of the character. If the
return value is -1, then s is a string that only contains the
specified character and no other characters (apart from the
string terminator character). A return value of 0 means that
there is no leading sequence of separator characters.
Rules for part 2
1. The functions are defined in utils.h. The comments to each
function define the contract between yourself and the user of
these functions. Your implementations must satisfy the contract
and the descriptions above.
2. You must implement the functions in a separate utils.c file
that includes utils.h
3. utils.c must not contain a main function.
4. The only C library function you can use in your
implementation is getchar in stdio to read characters one at a
time from stdin. You must not use any other library functions.
That is, use of the C library getline function or any string
processing library functions is forbidden.
Example usage
The following program shows example usage of the three
functions: getaline, trim and split.
#include <stdio.h> #include "utils.h" /* constant buffer
sizes - define appropriate values */ #define MAX_LINE 80
#define MAX_SUBS 10 int main(void) { char
linebuf[MAX_LINE]; char *substr[MAX_SUBS];
char sep = ' '; int start; int count; int i;
/* get a string of characters of user input */ if
(getaline(linebuf, MAX_LINE) > 0) { /* trim leading
and trailing spaces */ start = trim(linebuf, sep);
/* split linebuf at each space character */ count =
split(linebuf, start, sep, substr, MAX_SUBS);
printf("number of substrings: %dn", count); /* if
this is command line input from the user * substr[0] is
the command * substr[1] ... substr[count-1] are the

parameters */ for (i = 0; i < count; i++)
printf("substring %d: %sn", i, substr[i]); } }
Hints
1. You can use the above program as the basis for tests of your
functions. But don't try to do all three functions at once. You
may find it easier to do split and trim first and then dogetaline.
You can test split and trim on any array of null character
terminated characters (i.e. a statically declared string as
opposed to one obtained from user input).
2. The input strings (character buffers)
to getaline, split and trim must be modifiable.
3. Replacing a character in a string with the null
terminator '0' in effect creates two strings.
4. You should test for end of line ('n') and the end of file (EOF)
when reading user input.
5. When splitting a string that contains 2 or more consecutive
separator characters, consider the following example. A string
has two consecutive separator characters followed by a non-
separator character. In this case, one substring will end at the
position of the first separator character. The next substring will
start at the position after the second separator character (i.e. the
first character of the next substring will be the non-separator
character).
6. Do not try to be too clever in your implementation or use of
these functions. Their main purpose is to read MINIX
commands typed at your simple shell prompt. You
need trim andsplit to treat a single line of user input as
sequence of strings (i.e. the command and any parameters).
Part 2 deliverables
The deliverables for Part 3 are the files utils.h and utils.c
Note: if you get stuck on this part, you may use standard C
library functions for user input to your shell in part 3 (with a
penalty in lost marks).
Part 3 - simple shell
In this part you will implement the simple shell (command line
processor) described in the lectures for Part 1 of the module

(see slide 47 of the slides for Part 1 lectures).
The outline of the basic shell is as follows:
Repeat forever display a user prompt (for the user to enter
a MINIX command) read and process the user input (using
getaline, trim and split) fork a child process in the
parent: wait for the child to finish in the child: execve
the user command with any parameters
Rules for part 3
1. You must implement the shell in a separate myshell.c file.
2. For the user prompt, you should use the C
library putchar function in stdio (i.e. do not use printf).
3. You must document any additional functionality of your shell
in comments in the myshell.c file (see breakdown of marks
below).
Part 3 breakdown of marks
· 4 marks for the basic shell functionality
· Additional marks are available for extensions to the basic
functionality, such as:
· using the functions you implemented in part 2 of the
assignment
· detecting and reporting errors in user commands entered (e.g.
outputting an error message if the user enters an incorrect
command - see errno and perror)
· detecting and continuing if no command is entered (e.g. the
user just enters return at the prompt)
· providing a command for the user to exit the shell (e.g. exiting
if the user enters q at the prompt)
· other enhancements of your own that make the shell more
usable
Additional functionality in your shell can compensate for lost
marks in other parts of the assignment. You must document
additional functionality of the shell in comments in
your myshell.cfile.
Part 3 deliverables
The deliverable for Part 3 is the myshell.c file.
To obtain full marks for this part you should

use utils.h and utils.c as a library for your simple shell in part
3. That is, use your utility functions to process user input at
your shell's command line. However, if you get stuck on this
part, you may use standard C library functions to obtain user
input to your shell.
4. Compiling programs with multiple files
To compile a single C program, e.g. myprogram.c, in the current
directory, type:
# cc myprogram.c
If successful, this will compile the program and output an
executable to a.out. You can specify a different executable as
follows:
# cc myprogram.c -o myprogram
In this assignment you will be working with multiple files. To
keep things simple, all files should be in the same directory.
For example, for part 1 you will have the following
files: intmath.h, intmath.c and a test program with
a main function, e.g. intmath_test.c.
This means that you will have to compile and link multiple files
to produce an executable. This is a two stage process with
the cc compiler. First produce individual object files with the -
coption to the compiler, as follows:
# cc -c intmath.c intmath_test.c
If successful, you will now have two object
files: intmath.o and intmath.o.
Now use cc to link the object files and produce an executable
named intmath_test, as follows:
# cc intmath.o intmath_test.o -o intmath_test
The process is the same for parts 2 and 3, with different file
names.
When you want to recompile, first remove all object files (with
extension ".o") and existing executables. Then repeat the two
step compilation above. A Makefile and make can be used to
script the whole process of compilation, linking and cleaning
(removing) old files.

5. Mark scheme
Marks will be awarded as follows:
· 4 marks for the implementation of arithmetic functions
· 8 marks for the implementation of user input utilities
· 8 marks for the simple shell
This assignment is worth 20% of the coursework component of
the module and 4% of the module mark.
1. Aim
The aim of this assignment is for you to gain some practice in C
programming, to use C libraries and system calls, and to
demonstrate your
understanding of C and how to program to a defined interface.
2. Learning/skills outcomes
·
C programming
skills
·
Programming to defined interfaces
·
Formulate problems and identify suitable approaches to solving
them
·

Cognitive/intellectual skills and self management (see graduate
skills
framework)
3. Specification
This assignment has three parts:
1.
Write a library of simple arithmetic functions
(4 marks)
2.
Write a library of utilities to read and process user input
(8 marks)
3.
Write a simple command line shell
(8 marks)
Note
we will test your solution programmatically on MINIX. It is
very
important that
you follow the rules below for the form of your solutions and
their submission. For example, do not deviate from the file
names specified.

If you do not adhere to the rules, you will loose marks even if
your solution
is logically correct. An important purp
ose of this assignment is for you to
demonstrate that you can understand an interface definition and
program to
that definition. It is also important that your code executes
correctly on
MINIX.
You will also have to test your solutions yourself. We will no
t mark these
tests and they should not be submitted. The files that you
submit are:
·
intmath.h
-
unmodified,
provided for you
·
intmath.c
-
your implementation of the functions
defined
in

intmath.h
·
utils.h
-
unmodified,
provided for you
·
utils.c
-
your implementation of the functions defined in
utils.h
·
myshell.c
-
your implemenation of a simple shel
that uses the
functions defined in
utils.h

A simple shell (command interpreter) #define TRUE 1! dec.docx

A simple shell (command interpreter) #define TRUE 1! dec.docx

Recommended

Recommended

More Related Content

Similar to A simple shell (command interpreter) #define TRUE 1! dec.docx

Similar to A simple shell (command interpreter) #define TRUE 1! dec.docx (20)

More from annetnash8266

More from annetnash8266 (20)

Recently uploaded

Recently uploaded (20)

A simple shell (command interpreter) #define TRUE 1! dec.docx