./shell <input file>

The shell will fork and execute each process as a child process so that in the event of an infinite loop the terminal can still respond to the SIGTERM command. Output can be piped to an external file using the “>” operator. In the event that the destination file is not found, it is created with the permissions 755. The permissions and line length can be changed in the parameters in the header file below.

The header files declares the two functions which will be used. The trimspace function trims a given string of leading and trailing spaces. The executecmd function is given a command line to execute.

shell.h:

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/wait.h>
#include <unistd.h>
#include <ctype.h>

#define MAX_ARGS 512
#define PERMS 0755

char *trimspace(char *str);
void executecmd(char *commands);

shell.c:

#include "537sh.h"

// Trim function from code @:
// http://goo.gl/gVRb
char *trimspace(char *str){
	char *last;

	while(isspace(*str)) {
		 str++;
	}
	if(*str == 0) {
		return str;
	}

	last = str + strlen(str) - 1;
	while(last > str && isspace(*last)) {
		 last--;
	}

	*(last + 1) = 0;

	return str;
}

The executecmd function:

This function sets up the default error message to output on any type of error, and a variable to store the child process ID information.

void executecmd(char *commands) {
	char error_message[30] = "An error has occurred\n";
	pid_t child_pid;

It then checks to see if the “+” operator is used. This operator is used to feed more than one command per line. It works similar to the “&&” operator in the Linux shell.

	// Split the input line if the multiple cmd operator is used
	char *argv_parent[MAX_ARGS];
	int more_args_parent = 1;
	int argv_index_parent = 0;

	argv_parent[argv_index_parent++] = strtok(commands, "+");
	while(more_args_parent) {
		argv_parent[argv_index_parent++] = strtok(NULL, "+");
		if(argv_parent[argv_index_parent - 1] == NULL) more_args_parent = 0;
	}

Since every command can have a redirect to an output file “+“, or a sorted redirect to an output file “==” it must check every individual command which was separated using the string tokenizer strtok.

	// For every split command fork & exec
	int i;
	for(i = 0; i < argv_index_parent; i++) {
		// Variables
		char *redirect = (char*) malloc(512);
		char *redirraw = NULL;
		char *sortredirraw = NULL;
		char *redirect_args[MAX_ARGS];
		int more_args_redirect = 1;
		int index_redirect = 0;

		if(argv_parent[i] != NULL) {
			redirraw = strchr(argv_parent[i], '>');
			sortredirraw = strstr(argv_parent[i], "==");

			if(redirraw != NULL) {
				redirect_args[index_redirect++] = strtok(argv_parent[i], ">");
				while(more_args_redirect) {
					redirect_args[index_redirect++] = strtok(NULL, ">");
					if(redirect_args[index_redirect - 1] == NULL) more_args_redirect = 0;
				}
				if(redirect_args[1] != NULL) {
					// There must be a redirect location
					redirect = trimspace(redirect_args[1]);
				}
			}
			else if(sortredirraw != NULL) {
				redirect_args[index_redirect++] = strtok(argv_parent[i], "==");
				while(more_args_redirect) {
					redirect_args[index_redirect++] = strtok(NULL, "==");
					if(redirect_args[index_redirect - 1] == NULL) more_args_redirect = 0;
				}
				if(redirect_args[1] != NULL) {
					// There must be a redirect location
					redirect = trimspace(redirect_args[1]);
				}
			}
		}

The shell implements 3 built in commands exit, cd, and pwd. If the exit command is found anywhere in a line containing multiple commands, the shell child process immediately exits and execution of the commands following the current one are not carried out. If the cd command is executed without any parameters, the shell switches to the user’s home directory, detected with the getenv(“HOME”) system call, much like cd ~ would do in UNIX. If a path is specified, the current directory is changed to it using the chdir system call, unless the path does not exist, in which case an error is displayed. The pwd command utilizes the getcwd system call to get the current working directory and displays it on the screen.

		/**
		 * BUILT IN COMMANDS
		 **/

		// EXIT
		if(argv_parent[i] != NULL && strcmp(trimspace(argv_parent[i]), "exit") == 0) exit(0);

		// PWD
		else if(argv_parent[i] != NULL && strncmp(trimspace(argv_parent[i]), "pwd", 3) == 0) {
			if(strcmp(trimspace(argv_parent[i]), "pwd") == 0) {
			char directory[MAX_ARGS];
				getcwd(directory, MAX_ARGS);
				strcat(directory, "\n");
				write(STDOUT_FILENO, directory, strlen(directory));
			}
			else {
				write(STDERR_FILENO, error_message, strlen(error_message));
			}
		}

		// CD
		else if(argv_parent[i] != NULL && strncmp(trimspace(argv_parent[i]), "cd", 2) == 0) {
			if(strlen(argv_parent[i]) > 3) {
				// Split the string @ char 3 & trim white spaces
				char *directory = (char*) malloc(strlen(argv_parent[i])-2);
				strncpy(directory, trimspace(argv_parent[i])+2, strlen(argv_parent[i]));
				directory = trimspace(directory);
				if(chdir(directory) == -1) {
					write(STDERR_FILENO, error_message, strlen(error_message));
				}
			}
			else {
				chdir(getenv("HOME"));
			}
		}

All other commands are handled by the execvp system call. Since the output of any of these commands can be redirected, we must check to see if the redirection character has been detected. If it has, then we know that we need to get two arguments rather than 1 from the array of commands. Each command is then executed as a child process using the fork system call. For the piping commands, the output is redirected to the specified file using the dup2 system call. For the sorted redirect, a pipe must be created so that the output of the command is fed into the input of the sort command. The output of the sort is then sent to the external file specified.

		/**
		 * SYSTEM COMMANDS
		 **/
		else {
			// Check if this is an empty command, if it is do nothing
			if(argv_parent[i] != NULL && strcmp(trimspace(argv_parent[i]), "") != 0) {

				// Sorted redirect variables
				int fd[2];
				int secondChild_pid = -1; // Neg means it failed

				if(redirect != NULL && strlen(redirect) > 0 && strstr(redirect, " ") != NULL) {
					// There must be two output files separated by space
					write(STDERR_FILENO, error_message, strlen(error_message));
					exit(0);
				}

				if(sortredirraw != NULL && redirect != NULL && strlen(redirect) > 0)
					pipe(fd);

				child_pid = fork();
				if(child_pid == 0) {
					char *argv[MAX_ARGS];
					int more_args = 1;
					int argv_index = 0;

					if(redirraw != NULL && redirect != NULL && strlen(redirect) > 0) {
						int file = open(redirect, O_CREAT | O_WRONLY, PERMS);
						if(file == -1) {
							// File not found
							write(STDERR_FILENO, error_message, strlen(error_message));
							exit(1);
						}
						dup2(file, 1);
					}
					else if(redirraw != NULL && redirect != NULL && strlen(redirect) == 0) {
						write(STDERR_FILENO, error_message, strlen(error_message));
						exit(1);
					}
					else if(sortredirraw != NULL && redirect != NULL && strlen(redirect) > 0) {
						close(fd[0]);
						dup2(fd[1], STDOUT_FILENO);
					}
					else if(sortredirraw != NULL && redirect != NULL && strlen(redirect) == 0) {
						write(STDERR_FILENO, error_message, strlen(error_message));
						exit(1);
					}

					// Determine the command arguments
					argv[argv_index++] = strtok(argv_parent[i], " ");
					while(more_args) {
						argv[argv_index++] = strtok(NULL, " ");
						if(argv[argv_index - 1] == NULL) more_args = 0;
					}
					if(execvp(argv[0], argv)) {
						// This executes if there's an error
						write(STDERR_FILENO, error_message, strlen(error_message));
						exit(0);
					}
				}
				else if(child_pid < 0) {
					fprintf(stderr, "Fork Failed");
					exit(1);
				}
				else {
					// Code executed by parent
					if(sortredirraw != NULL && redirect != NULL && strlen(redirect) > 0) {
						secondChild_pid = fork();
						if(secondChild_pid == 0) {
						// Child code
							close(fd[1]);
							dup2(fd[0], STDIN_FILENO);
							int file = open(redirect, O_CREAT | O_WRONLY, PERMS);

							if(file == -1) {
								// File not found
								write(STDERR_FILENO, error_message, strlen(error_message));
								exit(1);
							}
							else
								dup2(file, STDOUT_FILENO);

							char *sortarg[2] = {"sort", NULL};

							// SORT
							execvp(sortarg[0], sortarg);
							write(STDERR_FILENO, error_message, strlen(error_message));
							exit(0);
						}
						else if(child_pid < 0) {
							fprintf(stderr, "Fork Failed");
							exit(1);
						}
					}
					close(fd[1]);
					if(sortredirraw != NULL && redirect != NULL && strlen(redirect) > 0)
						close(fd[0]);
					waitpid(child_pid, NULL, 0);
					if(sortredirraw != NULL && redirect != NULL && strlen(redirect) > 0)
						waitpid(secondChild_pid, NULL, 0);
				}
			}
		}
	}
}

main function:
The main function determines if the application will run in shell mode, or batch mode. In batch mode it takes the line inputs from a file, while shell mode loops the prompt until the exit command is entered. If more than one input file are specified or the input file is not found, an error is displayed.

int main (int argc, char *argv[]) {
	char commands[MAX_ARGS];
	char error_message[30] = "An error has occurred\n";
	char cmdline[8] = "537sh% ";

	if(argc == 1) {
		while(strcmp(trimspace(commands), "exit") != 0) {
			// STDIN
			write(STDOUT_FILENO, cmdline, strlen(cmdline));
			fgets(commands, MAX_ARGS, stdin);
			if(strchr(commands, '\n') ==  NULL) {
				// Output an error since the line was truncated
				write(STDERR_FILENO, error_message, strlen(error_message));
			}
			else {
				// Execute the command if the line is good
				executecmd(commands);
			}
		}
	}
	else if(argc == 2){
		// Batch input
		FILE *input = fopen(argv[1], "r");
		if(input != NULL) {
			while(fgets(commands, MAX_ARGS, input) != NULL) {
				if(strchr(commands, '\n') == NULL)
					strcat(commands, "\n");
				write(STDOUT_FILENO, commands, strlen(commands));
				executecmd(commands);
			}
		}
		else {
			write(STDERR_FILENO, error_message, strlen(error_message));
			exit(1);
		}
	}
	else {
		write(STDERR_FILENO, error_message, strlen(error_message));
		exit(1);
	}

	return 0;

}

This sample register file will be a 16 entries by 8-bits per entry. It will have 2 synchronous write ports, and an asynchronous read port as well as an active low asynchronous reset.

We begin with our module header, parameters, and i/o declarations.

module register_file(data_out, clk, wr_en_1, wr_en_2, rst, data_in_1, data_in_2,	wr_addr_1, wr_addr_2, rd_addr);

	parameter ENTRIES = 16;
	parameter REG_OFFSET = 8;
	integer i;

	input clk, wr_en_1, wr_en_2, rst;
	input [7:0] data_in_1, data_in_2;
	input [2:0] wr_addr_1, wr_addr_2;
	input [3:0] rd_addr;
	output reg [7:0] data_out;

	reg [7:0] registers [ENTRIES - 1:0];

By using parameters we can easily create register files of different sizes by passing new parameter values during instantiation. This can be done as such:

register_file #(16, 32) reg_file(data_out, clk, wr_en_1, wr_en_2, rst, data_in_1, data_in_2,	wr_addr_1, wr_addr_2, rd_addr);

This will instantiate the same module with 16 32-bit entries.

Inside our module in an always block we declare that we want it to execute only in case of a clock’s positive edge, or a reset’s negative edge. Since the rest is active low, it will change states from 1->0 (negative edge).

always @(posedge clk, negedge rst) begin

We then take care of our two write ports and reset. If reset is equal to 0, then we need to reset all of the values in the register file. Otherwise if wr_en_1 is 1, we want to write to write port 1, else we want to write to write port 2.

always @(posedge clk, negedge rst) begin
		if(rst == 1'b0) begin
			for(i = 0; i < ENTRIES; i = i + 1) begin
				registers[i] <= 7'b0;
			end
		end

		else if(wr_en_1)
			registers[wr_addr_1] <= data_in_1;
		else
			registers[REG_OFFSET + wr_addr_2] <= data_in_2;
end

That take care of the two synchronous write ports. Since hardware operations occur in parallel, we can have multiple always blocs which will all execute at the same time. For the write port we simply want the always block to be triggered every time the read address (read_addr) changes.

always @(rd_addr) begin
		data_out = registers[rd_addr];
end

And this is the complete code for the register file:
register_file.v:

module register_file(data_out, clk, wr_en_1, wr_en_2, rst, data_in_1, data_in_2,	wr_addr_1, wr_addr_2, rd_addr);

	parameter ENTRIES = 16;
	parameter REG_OFFSET = 8;
	integer i;

	input clk, wr_en_1, wr_en_2, rst;
	input [7:0] data_in_1, data_in_2;
	input [2:0] wr_addr_1, wr_addr_2;
	input [3:0] rd_addr;
	output reg [7:0] data_out;

	reg [7:0] registers [ENTRIES - 1:0];

	always @(posedge clk, negedge rst) begin
		if(rst == 1'b0) begin
			for(i = 0; i < ENTRIES; i = i + 1) begin
				registers[i] <= 7'b0;
			end
		end

		else if(wr_en_1)
			registers[wr_addr_1] <= data_in_1;
		else
			registers[REG_OFFSET + wr_addr_2] <= data_in_2;
	end

	always @(rd_addr) begin
		data_out = registers[rd_addr];
	end

endmodule

The mode function sorts the vector and iterates through it keeping a count of how many times the current value appears. Since the array is in sorted order, we know that if the next value is greater than the current, then we must be done counting the current, so it can be added to a temporary vector. If a new value is found, which has a greater count than the current highest, then the vector is cleared and the new value is added. If the new value has a count equal to that of the current high count, it is added to the temporary vector. The temporary vector is returned at the end.

Function Descriptions:

The median function check to see if the vector has an even number of items. If it does, then the median is computed as the average of the two medians of the vector in sorted order. Otherwise, the median is the result of the middle value. The return type for this function is float because of the need to represent decimals in cases when the average must be taken.

The mean function iterates through the vector taking the sum of all the values, then divides them by the total number of items in the vector. The return type is a double for large numbers which require greater precision than a float can provide.

Header File:

#include <iostream>
#include <vector>
#include <iterator>
#include <algorithm>
#include <fstream>

using namespace std;

template <typename T> vector<int> mode(vector<T> &data);
template <typename T> float median(vector<T> &data);
template <typename T> double mean(vector<T> &data);

Main:

#include "mean_median_mode.h"

int main(int argc, char *argv[]) {
	// Function declaration

	vector<int> data;

	// Load a small set of variables into the vector

	int input_int;
	ifstream infile(argv[1]);

	if(!infile) {
		if(argv[1] != NULL) {
			// There was an error opening the file
			cout << "There was an error opening "
				<< argv[1]
				<< " for reading."
				<< endl;
		}
		else {
			cout << "Syntax error. mean_median_mode <input file name>" << endl;
		}

	}

	else {
		while (infile >> input_int) {
			data.push_back(input_int);
		}

		sort(data.begin(), data.end());
		cout << "Data Set: ";
		int j;
		for (j = 0; j < data.size(); j++) {
			printf("%i ", data[j]);
		}
		cout << endl;

		printf("Mean: %f Median: %f, Mode: ", mean(data), median(data));
		vector<int> tmp = mode(data);
		int i;

		for(i = 0; i < tmp.size(); i++) {
			printf("%i ", tmp[i]);
		}
		printf("\n");
	}

	return 0;
}

template <typename T> vector<int> mode(vector<T> &data) {
	vector<int> tmp_vector;

	if(data.size() > 0) {
		sort(data.begin(), data.end());
		vector<int>::iterator i;
		i = data.begin();

		int highest_mode = 0;
		int highest_mode_count = 0;
		int current_mode = 0;
		int current_count = 0;

		// Iterate through the vector
		while(i != data.end()) {
			int tmp = *i;

			if(current_count == 0) {
				current_mode = tmp;
			}

			if(tmp == current_mode) {
				current_count++;
			}
			else if(tmp > current_mode) {

				// Check if the current mode is greater than the highest
				if(current_count > highest_mode_count) {
					// Make the current mode the highest
					highest_mode = current_mode;
					highest_mode_count = current_count;

					// Clear the vector
					tmp_vector.clear();

					// Add the highest value to the vector
					tmp_vector.push_back(highest_mode);

					// Set current to tmp
					current_mode = tmp;
					current_count = 1;
				}

				// In case multiple modes
				else if(current_count == highest_mode_count) {
					// Set the highest mode to current
					highest_mode = current_mode;
					highest_mode_count = current_count;

					// Add the current mode to the vector
					tmp_vector.push_back(current_mode);

					current_mode = tmp;
					current_count = 1;
				}

				else {
					// Set tmp to current
					current_mode = tmp;
					current_count = 1;
				}
			}
			else {
				// Shouldn't need to do anything if tmp < current_mode
			}

			i++;
		}
	}

	return tmp_vector;
}

template <typename T> float median(vector<T> &data) {
	if(data.size() > 0) {
		// Sort the data
		sort(data.begin(), data.end());

		// Handle the even cases
		if((data.size() % 2) == 0) {
			// To get the median value sum the 2 medians and get the average
			float sum = 0;

			sum += data[data.size()/2];
			sum += data[(data.size()/2) - 1];

			return (sum/2);
		}

		// Handle the odd cases
		else {
			return data[data.size()/2];
		}
	}

	return 0;
}

template <typename T> double mean(vector<T> &data) {
	if(data.size() > 0) {
		vector<int>::iterator i;
		double sum = 0;

		// Iterate through all of the elements in the vector and sum them
		for(i = data.begin(); i != data.end(); i++) {
			sum += *i;
		}

		return sum/data.size();
	}

	return 0;
}

Makefile:

all: mean_median_mode

mean_median_mode: mean_median_mode.h mean_median_mode.cpp
	g++ -o mean_median_mode mean_median_mode.cpp

clean:
	rm mean_median_mode

/**
 * SyntaxHighlighter Verilog Brush
 * http://hdelossantos.com/
 *
 * SyntaxHighlighter is donationware. If you are using it, please donate.
 * http://alexgorbatchev.com/wiki/SyntaxHighlighter:Donate
 *
 * @version
 * 1.0.0 (May 20, 2010)
 *
 * @copyright
 * Copyright (C) 2010 Hanly De Los Santos.
 *
 * @license
 * This file is a SyntaxHighlighter brush and is licensed under
 * the same license as SyntaxHighlighter.
 *
 * SyntaxHighlighter is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * SyntaxHighlighter is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with SyntaxHighlighter.  If not, see <http://www.gnu.org/copyleft/lesser.html>.
 */
SyntaxHighlighter.brushes.Verilog = function() {
	var keywords = 'always end ifnone or rpmos tranif1 and endcase ' +
			  'initial output rtran tri assign endmodule inout ' +
			  'parameter rtranif0 tri0 begin endfunction input ' +
			  'pmos rtranif1 tri1 buf endprimitive integer ' +
			  'posedge scalared triand bufif0 endspecify join ' +
			  'primitive small trior bufif1 endtable large pull0 ' +
			  'specify trireg case endtask macromodule pull1 ' +
			  'specparam vectored casex event medium pullup ' +
			  'strong0 wait casez for module pulldown strong1 ' +
			  'wand cmos force nand rcmos supply0 weak0 deassign ' +
			  'forever negedge real supply1 weak1 default for ' +
			  'nmos realtime table while defparam function nor ' +
			  'reg task wire disable highz0 not release time wor ' +
			  'edge highz1 notif0 repeat tran xnor else if ' +
			  'notif1 rnmos tranif0 xor';
	var sysTasks = '$display $monitor $dumpall $dumpfile $dumpflush ' +
			  '$dumplimit $dumpoff $dumpon $dumpvars $fclose ' +
			  '$fdisplay $fopen $finish $fmonitor $fstrobe ' +
			  '$fwrite $fgetc $ungetc $fgets $fscanf $fread ' +
			  '$ftell $fseek $frewind $ferror $fflush $feof ' +
			  '$random $readmemb $readmemh $readmemx $signed ' +
			  '$stime $stop $strobe $time $unsigned $write';
	var macros = 'default-net define celldefine default_nettype ' +
			  'else elsif endcelldefine endif ifdef ifndef ' +
			  'include line nounconnected_drive resetall ' +
			  'timescale unconnected_drive undef';

	this.regexList = [
		{ regex: SyntaxHighlighter.regexLib.singleLineCComments,	css: 'comments' },
		{ regex: /\/\*([^\*][\s\S]*)?\*\//gm,						css: 'comments' },
		{ regex: /\/\*(?!\*\/)\*[\s\S]*?\*\//gm,					css: 'preprocessor' },
		{ regex: SyntaxHighlighter.regexLib.doubleQuotedString,		css: 'string' },
		{ regex: SyntaxHighlighter.regexLib.singleQuotedString,		css: 'string' },
		{ regex: /\b([\d]+(\.[\d]+)?|0x[a-f0-9]+)\b/gi,			css: 'value' },
		{ regex: /(?!\@interface\b)\@[\$\w]+\b/g,			css: 'color1' },
		{ regex: /\@interface\b/g,					css: 'color2' },
		{ regex: new RegExp(this.getKeywords(keywords), 'gm'),		css: 'keyword' },
		{ regex: new RegExp(this.getKeywords(macros), 'gm'),		css: 'keyword' },
		{ regex: new RegExp(this.getKeywords(sysTasks), 'gm'),		css: 'keyword' }
];

};

SyntaxHighlighter.brushes.Verilog.prototype = new SyntaxHighlighter.Highlighter();
SyntaxHighlighter.brushes.Verilog.aliases = ['verilog', 'v'];

You can download the WordPress plugin below. You must have the SyntaxHighlighter plugin installed and active.

[ad#Google Adsense Text Ad Post]