u32 get_random_u32(void)
{
return (get_next_byte() << 24)
| (get_next_byte() << 16)
| (get_next_byte() << 8)
| get_next_byte();
}
//Create_buffer simply stores the file into a buffer
char* create_buffer(int(*get_next_byte) (void *), void *get_next_byte_argument)
{
size_t iter = 0;
size_t buffer_size = 1024;
char *buffer = (char *)checked_malloc(buffer_size);
char current_byte;
//Iterates through entire file
while ((current_byte = get_next_byte(get_next_byte_argument)) != EOF)
{
//Skips over characters included in a comment
if (current_byte == '#')
{
while ((current_byte = get_next_byte(get_next_byte_argument)) != '\n')
{
if (current_byte == EOF)
break;
//fprintf(stderr, "%d", current_byte);
//Continue iterating until the end of the comment is reached.
}
continue;
}
buffer[iter++] = current_byte;
if (iter == buffer_size)
buffer = (char *)checked_grow_alloc(buffer, &buffer_size);
}
buffer[iter] = '\0';
fprintf(stderr, "%s", buffer);
return buffer;
}
static void scr_notifications_draw_screen() {
uint32_t read_address = notifications_get_current_data();
uint8_t notification_type = get_next_byte(&read_address);
switch(notification_type) {
case NOTIFICATIONS_CATEGORY_MESSAGE:
case NOTIFICATIONS_CATEGORY_EMAIL:
case NOTIFICATIONS_CATEGORY_SOCIAL:
case NOTIFICATIONS_CATEGORY_ALARM:
case NOTIFICATIONS_CATEGORY_INCOMING_CALL:
case NOTIFICATIONS_CATEGORY_OTHER:
{
uint16_t notification_id = get_next_short(&read_address);
uint8_t page = get_next_byte(&read_address);
uint8_t font = get_next_byte(&read_address);
bool has_more = get_next_byte(&read_address);
char* data_ptr = (char*)(0x80000000 + read_address);
mlcd_draw_text(data_ptr, 3, 3, MLCD_XRES - 6, MLCD_YRES - 6, font, HORIZONTAL_ALIGN_LEFT | MULTILINE);
}
break;
case NOTIFICATIONS_CATEGORY_SUMMARY:
{
uint8_t notification_count = get_next_byte(&read_address);
if (notification_count>9) {
notification_count = 9;
}
mlcd_draw_digit(notification_count, 20, 20, MLCD_XRES-40, MLCD_YRES-40, 11);
}
break;
}
}
command_stream_t
make_command_stream (int (*get_next_byte) (void *),
void *get_next_byte_argument)
{
/* FIXME: Replace this with your implementation. You may need to
add auxiliary functions and otherwise modify the source code.
You can also use external functions defined in the GNU C Library.
*/
char c = get_next_byte(get_next_byte_argument);
//printf("%c",c);
// read into big buffer
// iterate through buffer, capturing 2 characters (pair) at a time
// if pair is an operator, then do stuff
// else add pair[0] to word
char buffer[1024] = "";
int len = 0;
while (c != EOF)
{
buffer[len]=c;
len++;
c = get_next_byte(get_next_byte_argument);
}
buffer[len++] = EOF;
// printf("==== buffer ====\n%s\n==== end buffer ====\n", buffer);
command_stream* command_list = malloc(sizeof(struct command_stream));
build_command_stream_from_buffer(command_list, buffer, len);
return command_list;
}
char* read_into_buffer(int (*get_next_byte) (void *), void *get_next_byte_argument) {
size_t n, buf_size;
char next_byte;
char *buf;
buf_size = 1024;
n = 0;
buf = (char *) checked_malloc(sizeof(char)*buf_size);
while ((next_byte = get_next_byte(get_next_byte_argument)) != EOF) {
if (next_byte == '#') {
next_byte = get_next_byte(get_next_byte_argument);
while (next_byte != '\n' && next_byte != EOF)
next_byte = get_next_byte(get_next_byte_argument);
}
if (next_byte != EOF) {
buf[n] = next_byte;
n++;
if (n == buf_size)
buf = checked_grow_alloc(buf, &buf_size);
}
}
if (n < buf_size - 1) {
buf[n] = '\0';
} else {
buf = (char *) checked_grow_alloc(buf, &buf_size);
buf[n] = '\0';
}
return buf;
}
command_stream_t make_command_stream (int (*get_next_byte) (void *), void *get_next_byte_arg)
{
size_t count = 0;
size_t buffer_size = 1000;
char* buffer = checked_malloc(buffer_size);
//create a buffer of charactors to store the readin chars
// create buffer of input with comments stripped out
char ch;
do
{
ch = get_next_byte(get_next_byte_arg);
if (ch == '#') // for comments: ignore everything until '\n' or EOF
{
ch = get_next_byte(get_next_byte_arg);
while(ch != EOF && ch!='\n')
ch = get_next_byte(get_next_byte_arg);
}
//skip all the words until \n
if (ch!= -1)
{
// load into buffer
buffer[count] = ch;
count++;
// expand buffer if necessary
//if (count == INT_MAX)
//{
// error(1, 0, "Line -1: Input size over INT_MAX.");
//}
if (count == buffer_size)
{
buffer_size = buffer_size * 2;
buffer = checked_grow_alloc (buffer, &buffer_size);
}
}
} while(ch != -1);
token_stream_t return_point = convert_buffer_to_token_stream(buffer,count);
//build command_tree
//nuild the first command_tree
//command_stream_t command_stream_first = init_command_stream ();
command_t new_command_t = make_command_tree (return_point);
add_command_to_stream(new_command_t );
//build the rest command_tree
while (return_point->next != NULL)
{
//make return_point point to next token stream
token_stream_t temp = return_point->next;
//free(return_point);
return_point = temp;
new_command_t = make_command_tree (return_point);
add_command_to_stream(new_command_t);
}
return command_stream_head;
}
int valid_operator(char c, char* word, enum command_type *cmd, struct linked_list *cmd_stack,
int(*get_next_byte) (void *), void *get_next_byte_argument)
{
char next;
//char *tmp;
int retval = 0;
if (c == ';') {
*cmd = SEQUENCE_COMMAND;
retval = 1;
}
else if (c == '(' || c == ')') {
*cmd = SUBSHELL_COMMAND;
retval = 1;
}
else if (c == '|') {
next = (char)get_next_byte(get_next_byte_argument);
if (next == '|') {
*cmd = OR_COMMAND;
}
else {
*cmd = PIPE_COMMAND;
char *temp = (char*)malloc(sizeof(char)*(strlen(word) - 1));
}
retval = 1;
}
else if (c == '&') {
next = get_next_byte(get_next_byte_argument);
if (next == '&') {
*cmd = AND_COMMAND;
}
retval = 1;
}
if (retval) {
//gotta push nontokenized string onto the command stack
//FIXME: Need to clean up this nontoken string and check for invalid syntax - as of now newlines and
//whitespace are a-ok and we gotta check for that - suggest creating another function
struct command simple_cmd;
simple_cmd.u.word = (char**)malloc(sizeof(char*));
*(simple_cmd.u.word) = (char*)malloc(sizeof(char)*strlen(word));
**(simple_cmd.u.word) = *word;
InsertAtHead(&simple_cmd, cmd_stack);
//now clean up the reference variable used in the parser
free(word);
word = "";
if (*cmd == PIPE_COMMAND) {
//tmp = (char *)malloc(sizeof(char) * strlen(&next))
//*tmp = next;
strcat(word, &next);
}
}
return retval;
}
// get several bytes as specified, the bytes may cross buffer boundary
// if succeed, the location info will be updated.
int get_bytes(buf_chain_t **curr_buf_node, int *next_byte_idx, char *buf, int size)
{
buf_chain_t *tmp_node = *curr_buf_node;
int tmp_nxt_idx = *next_byte_idx;
char c;
int i;
for(i = 0; i < size; i++)
{
if(0 == get_next_byte(&tmp_node, &tmp_nxt_idx, &c))
buf[i] = c;
else
break;
}
if(i == size)
{
*curr_buf_node = tmp_node;
*next_byte_idx = tmp_nxt_idx;
return 0;
}
else
{
return GET_BYTES_FAILED;
}
}
// get nexst field deliminated by ' '(a space)
// filling the output buffer. This may cross the buffer boundary.
// If the fucntion succeed, the location info will be updated
int get_next_field(buf_chain_t **curr_buf_node, int *next_byte_idx, char *buf, int buf_size)
{
assert(*curr_buf_node);
buf_chain_t *tmp_node = *curr_buf_node;
int tmp_nxt_idx = *next_byte_idx;
int cnt = 0;
int sp_found = 0;
char c;
while(0 == get_next_byte(&tmp_node, &tmp_nxt_idx, &c))
{
if(c != ' ')
break;
}
buf[0] = c;
cnt++;
while(0 == get_next_byte(&tmp_node, &tmp_nxt_idx, &c))
{
cnt++;
if(cnt > buf_size) //space will be replaced by '\0'
return NXT_FIELD_FAILED;
buf[cnt - 1] = c;
if(c == ' ')
{
sp_found = 1;
break;
}
}
if(sp_found == 1)
{
buf[cnt - 1] = '\0'; //repalce the space
dbg_print(1, "Function:%s:%.*s\n", __FUNCTION__, cnt, buf);
*curr_buf_node = tmp_node;
*next_byte_idx = tmp_nxt_idx;
return cnt;
}
else
{
return NXT_FIELD_NOMORE;
}
}
/* See comment to read_qword function, except return value. */
static inline void read_qword_only(reader_state * rs, uint_fast64_t * res)
{
*res = (((uint_fast64_t) get_next_byte(rs))) |
(((uint_fast64_t) get_next_byte(rs)) << 8u) |
(((uint_fast64_t) get_next_byte(rs)) << 16u) |
(((uint_fast64_t) get_next_byte(rs)) << 24u) |
(((uint_fast64_t) get_next_byte(rs)) << 32u) |
(((uint_fast64_t) get_next_byte(rs)) << 40u) |
(((uint_fast64_t) get_next_byte(rs)) << 48u) |
(((uint_fast64_t) get_next_byte(rs)) << 56u);
}
static uint8_t get_next_literal(decompression_state *state)
{
uint8_t c = get_next_byte(state);
/* if (isprint(c)) {
OC_DEBUG(3, "literal %c", c));
} else {
OC_DEBUG(3, "literal 0x%02x", c));
} */
return c;
}
/*
static void draw_incmonig_call_notification() {
uint32_t read_address = m_address + 1;
uint16_t param_1_offset = get_next_short(&read_address);
uint16_t param_2_offset = get_next_short(&read_address);
mlcd_draw_text(I18N_TRANSLATE(MESSAGE_INCOMING_CALL), 0, 5, MLCD_XRES, 20, FONT_OPTION_NORMAL, ALIGN_CENTER);
uint8_t data[32];
read_address = m_address + param_1_offset;
ext_ram_read_data(read_address, data, 32);
mlcd_draw_text((char*)data, 0, 60, MLCD_XRES, 20, FONT_OPTION_NORMAL, ALIGN_CENTER);
read_address = m_address + param_2_offset;
ext_ram_read_data(read_address, data, 32);
mlcd_draw_text((char*)data, 0, 90, MLCD_XRES, 20, FONT_OPTION_NORMAL, ALIGN_CENTER);
}
*/
static void draw_default_notification() {
uint32_t read_address = m_address + 1;
uint16_t text_offset = get_next_short(&read_address);
uint8_t font = get_next_byte(&read_address);
uint8_t operationsNo = get_next_byte(&read_address);
uint16_t op1_name_offset = operationsNo>0?get_next_short(&read_address):0;
uint16_t op2_name_offset = operationsNo>1?get_next_short(&read_address):0;
char* data_ptr = (char*)(0x80000000 + m_address + text_offset);
mlcd_draw_text(data_ptr, 3, 30, MLCD_XRES - 6, MLCD_YRES-60, font, HORIZONTAL_ALIGN_CENTER | MULTILINE | VERTICAL_ALIGN_CENTER);
if (op1_name_offset != 0) {
data_ptr = (char*)(0x80000000 + m_address + op1_name_offset);
mlcd_draw_text(data_ptr, 3, 0, MLCD_XRES-6, 30, font, HORIZONTAL_ALIGN_RIGHT | VERTICAL_ALIGN_CENTER);
}
if (op2_name_offset != 0) {
data_ptr = (char*)(0x80000000 + m_address + op2_name_offset);
mlcd_draw_text(data_ptr, 3, MLCD_YRES-30, MLCD_XRES-6, 30, font, HORIZONTAL_ALIGN_RIGHT | VERTICAL_ALIGN_CENTER);
}
}
static bool scr_notifications_handle_button_pressed(uint32_t button_id) {
switch (button_id) {
case SCR_EVENT_PARAM_BUTTON_BACK:
scr_mngr_close_notifications();
return true;
case SCR_EVENT_PARAM_BUTTON_UP:
{
uint32_t read_address = notifications_get_current_data();
uint8_t notification_type = get_next_byte(&read_address);
if (notification_type != NOTIFICATIONS_CATEGORY_SUMMARY) {
uint16_t notification_id = get_next_short(&read_address);
uint8_t page = get_next_byte(&read_address);
if (page > 0) {
notifications_prev_part(notification_id, page);
}
}
}
return true;
case SCR_EVENT_PARAM_BUTTON_DOWN:
{
uint32_t read_address = notifications_get_current_data();
uint8_t notification_type = get_next_byte(&read_address);
if (notification_type == NOTIFICATIONS_CATEGORY_SUMMARY) {
//show first
notifications_invoke_function(NOTIFICATIONS_SHOW_FIRST);
} else {
uint16_t notification_id = get_next_short(&read_address);
uint8_t page = get_next_byte(&read_address);
uint8_t font = get_next_byte(&read_address);
bool has_more = get_next_byte(&read_address);
if (has_more) {
notifications_next_part(notification_id, page);
} else {
notifications_next(notification_id);
}
}
}
return true;
case SCR_EVENT_PARAM_BUTTON_SELECT:
{
uint32_t read_address = notifications_get_current_data();
uint8_t notification_type = get_next_byte(&read_address);
if (notification_type != NOTIFICATIONS_CATEGORY_SUMMARY) {
uint16_t notification_id = get_next_short(&read_address);
notifications_open(notification_id);
}
}
return true;
}
return false;
}
void ignoreWhiteSpace(int (*get_next_byte) (void *),
void *get_next_byte_argument)
{
char c;
while ((c = get_next_byte(get_next_byte_argument)) != EOF &&
(c == ' ' || c == '\n')) {
;
}
if (c != EOF) {
_rewind(get_next_byte_argument, -1);
}
}
int gz_engine_run(void)
{
struct color color_reg = { 0x00, 0x00, 0x00 };
uint8_t n_leds = 0;
uint8_t i;
while (1)
{
enum op code = get_next_byte();
switch (code)
{
case OP_HALT:
return 0;
break;
case OP_DESCRIPTOR:
n_leds = get_next_byte();
break;
case OP_COLOR:
color_reg.r = get_next_byte();
color_reg.g = get_next_byte();
color_reg.b = get_next_byte();
break;
case OP_ALL_ON:
for (i = 0; i < n_leds; i++)
{
set_led(i, color_reg.r, color_reg.g, color_reg.b);
}
latch_leds();
break;
case OP_DELAY:
{
uint8_t lowMs;
uint8_t highMs;
lowMs = get_next_byte();
highMs = get_next_byte();
delay((uint16_t)(highMs << 8) | lowMs);
}
break;
default:
break;
}
}
return 0;
}
static bool scr_notifications_handle_button_long_pressed(uint32_t button_id) {
switch (button_id) {
case SCR_EVENT_PARAM_BUTTON_DOWN:
{
uint32_t read_address = notifications_get_current_data();
uint8_t notification_type = get_next_byte(&read_address);
if (notification_type != NOTIFICATIONS_CATEGORY_SUMMARY) {
uint16_t notification_id = get_next_short(&read_address);
notifications_next(notification_id);
}
}
return true;
}
return false;
}
file *rl_decode(const char *data, long size) {
int i;
byte_buffer *buff = new_buffer(size);
memcpy(buff->buffer, data, size);
// 1. Get size of each run.
uchar bytes[2];
for (i = 0; i < 2; ++i) {
bytes[i] = get_next_byte(buff);
}
const ushort NUM_BITS = *((ushort *)bytes);
// 2. Decode data
int zeros = 1;
int remaining = 8 * size;
int max_len = (4 * size)/3;
byte_buffer *output = new_buffer(max_len);
i = 0;
while (remaining > NUM_BITS) {
int bits = read_length(buff, NUM_BITS);
for (i = 0; i < bits; ++i) {
if (zeros) {
append_bit_to_buffer(output, 0);
} else {
append_bit_to_buffer(output, 1);
}
}
zeros = (zeros == 0)? 1 : 0;
remaining -= NUM_BITS;
}
// 3. Convert output buffer to file
file *f = (file *)malloc(sizeof(file));
f->size = (long)output->current_byte;
f->data = (char *)malloc(f->size);
memcpy(f->data, output->buffer, f->size);
// 4. Free resources
free_buffer(output);
free_buffer(buff);
return f;
}
int
fillRedirectionOperands(char **input, char **output,
int (*get_next_byte) (void *),
void *get_next_byte_argument)
{
int len = 0;
TOKENTYPE type = 0;
while (1) {
len = 0;
type = getTokenType(get_next_byte(get_next_byte_argument));
switch (type) {
case REDIRECTION1:
type = readNextToken(input, &len, get_next_byte,
get_next_byte_argument);
if (!(*input) || !strlen(*input)) {
goto err;
}
break;
case REDIRECTION2:
type = readNextToken(output, &len, get_next_byte,
get_next_byte_argument);
if (!(*output) || !strlen(*output)) {
goto err;
}
break;
default:
_rewind(get_next_byte_argument, -1);
goto out;
}
if (type == REDIRECTION2 || type == REDIRECTION1) {
continue;
} else {
break;
}
}
out:
return type;
err:
printErr();
return -1;
}
char* makeInputStream(int (*get_next_byte) (void *), void *get_next_byte_argument)
{
int inputStreamSize = 100;
int byteCount = 0;
int c;
char *inputStream = (char*)checked_malloc(inputStreamSize*sizeof(char));
while ((c = get_next_byte(get_next_byte_argument)) != EOF) {
inputStream[byteCount] = c;
byteCount++;
if (byteCount == inputStreamSize) {
inputStreamSize += 100;
inputStream = checked_realloc(inputStream, inputStreamSize*sizeof(char));
}
}
inputStream[byteCount] = EOF;
byteCount++;
return inputStream;
}
int
checkRedirection(int (*get_next_byte) (void *),
void *get_next_byte_argument)
{
char c;
int flag = 0;
while ((c = get_next_byte(get_next_byte_argument)) != EOF && c == ' ') {
;
}
switch (getTokenType(c)) {
case REDIRECTION1:
case REDIRECTION2:
flag = 1;
break;
default:
flag = 0;
break;
}
_rewind(get_next_byte_argument, -1);
return flag;
}
/*
* get_next_bit
*
* fetches the next bit for the data stream.
*
* returns: the next bit to be transmitted, already NRZI coded and bit stuffed
*/
uint8_t get_next_bit(void) {
static uint8_t byte = 0;
static uint8_t bit = 1;
static uint8_t bit_d = 0;
if (bitcnt >= 8) {
byte = get_next_byte();
bitcnt = 0;
}
/* all bytes LSB first */
bit = byte & 0x01;
if (bit) {
/* bit stuffing */
onecnt++;
if ((stuffing == 1) && (onecnt >= 5)) {
/* next time the same bit will be a zero -> stuffed bit */
byte &= ~0x01;
onecnt = 0;
} else {
byte >>= 1;
bitcnt = bitcnt + 1;
}
} else {
/* FIXME: Define the type 'struct command_stream' here. This should
complete the incomplete type declaration in command.h. */
command_stream_t make_command_stream(int(*get_next_byte) (void *),
void *get_next_byte_argument)
{
/* FIXME: Replace this with your implementation. You may need to
add auxiliary functions and otherwise modify the source code.
You can also use external functions defined in the GNU C Library. */
if (DEBUG) printf("291 Begin make_command_stream\n");
initStream();
size_t sizeofBuffer = 1024;
char* buffer = (char*)checked_malloc(sizeofBuffer);
char curr;
size_t filled = 0;
while ((curr = get_next_byte(get_next_byte_argument)) != EOF) {
buffer[filled] = curr;
filled++;
if (filled == sizeofBuffer) {
sizeofBuffer *= 2;
buffer = (char*)checked_grow_alloc(buffer, &sizeofBuffer);
}
}
//***For the parser:
//Word
int bufferWordSize = 10;
int currWord = 0;
//char ** wordElement;
char** wordElement = checked_malloc(sizeof(char*));
wordElement[currWord] = (char*)checked_malloc(bufferWordSize);
int usedWord = 0;
//Input
int bufferInputSize = 10;
char* inputElement = (char*)checked_malloc(bufferInputSize);
int usedInput = 0;
//Output
int bufferOutputSize = 10;
char* outputElement = (char*)checked_malloc(bufferOutputSize);
int usedOutput = 0;
//***Initialize operator and command stacks
initStacks();
if (DEBUG) printf("333 Buffer created, initStacks()\n");
int i = 0;
while (i < (int)filled)
{
if (DEBUG) printf("on buffer %d\n", i);
//***When you want to add a character*************************//
int op = -1;
int openCount = 0;
int closedCount = 0;
if (buffer[i] == '`')
error(1, 0, "Line %d: %c", __LINE__, buffer[i]);
if (buffer[i] == '(')
{
openCount = 1;
closedCount = 0;
int x = i;
while (x < (int) filled)
{
x++;
if (buffer[x] == '(')
openCount++;
if (buffer[x] == ')')
closedCount++;
if (closedCount == openCount)
break;
}
if (closedCount != openCount)
error(1, 0, "Line %d: Expected ')' for end of subshell", __LINE__);
}
if(buffer[i] == ')')
{
if(openCount == 0)
error(1, 0, "Line %d: Expected '(' before ')'", __LINE__);
}
if(buffer[i] = '(')
{
op = numberOfOper(&buffer[i]);
processOperator(op);
}
//Case of ' '
while (buffer[i] == ' ' && usedWord == 0)
i++;
if (buffer[i] == ' ' && usedWord != 0)
{
if (usedWord >= bufferWordSize)
{
bufferWordSize += 10;
wordElement[currWord] = (char*)checked_realloc(wordElement[currWord], bufferWordSize);
}
//i++;
wordElement[currWord][usedWord] = '\0';
while (buffer[i + 1] == ' ')
i++;
usedWord = 0;
bufferWordSize = 10;
currWord++;
wordElement[currWord] = (char*)checked_malloc(bufferWordSize);
//wordElement[currWord][usedWord] = buffer[i];
//usedWord++;
}
//Case of carrots
//WHAT IF a<b>c>d<a....?! You're making a simple command out of a<b>c which then
// must also be the word of >d<a
//Case of '<' first
else
if (buffer[i] == '<')
{
int k = i;
while (buffer[k-1] == ' ')
{
k--;
if(buffer[k-1] == '\n')
error(1, 0, "Line %d: Operator and word on diff lines", __LINE__);
}
if (wordElement[0][0] == '\0')
error(1, 0, "Line %d: No command given to '<'", __LINE__);
i++;
while (buffer[i] != '<' && buffer[i] != '>' && buffer[i] != '&' && buffer[i] != '|' && buffer[i] != '(' && buffer[i] != ')' && buffer[i] != ';' && buffer[i] != '\n')
{
if (i == filled)
{
if (DEBUG) printf("378 Complete command, free buffer bc EOF\n");
currWord++;
wordElement[currWord] = '\0';
if (usedInput == 0)
inputElement = NULL;
if (usedOutput == 0)
outputElement = NULL;
makeSimpleCommand(wordElement, inputElement, outputElement);
completeCommand();
//free(buffer);
return headStream;
}
if (buffer[i] == ' ')
i++;
else
{
if (usedInput >= bufferInputSize)
{
bufferInputSize += 10;
inputElement = (char*)checked_realloc(inputElement, bufferInputSize);
}
inputElement[usedInput] = buffer[i];
usedInput++;
i++;
}
}
if (usedInput >= bufferInputSize)
{
bufferInputSize += 10;
inputElement = (char*)checked_realloc(inputElement, bufferInputSize);
}
if (usedInput == 0)
error(1, 0, "Line %d: No input after '<'", __LINE__);
inputElement[usedInput] = '\0';
usedInput++;
if (buffer[i] == '>')
{
i++;
while (buffer[i] != '<' && buffer[i] != '>' && buffer[i] != '&' && buffer[i] != '|' && buffer[i] != '(' && buffer[i] != ')' && buffer[i] != ';' && buffer[i] != '\n')
{
if (i == filled)
{
if (DEBUG) printf("413 Complete command, free buffer at EOF\n");
currWord++;
wordElement[currWord] = '\0';
if (usedInput == 0)
inputElement = NULL;
if (usedOutput == 0)
outputElement = NULL;
makeSimpleCommand(wordElement, inputElement, outputElement);
completeCommand();
//free(buffer);
return headStream;
}
if (buffer[i] == ' ')
i++;
else
{
if (usedOutput >= bufferOutputSize)
{
bufferOutputSize += 10;
outputElement = (char*)checked_realloc(outputElement, bufferOutputSize);
}
outputElement[usedOutput] = buffer[i];
usedOutput++;
i++;
}
}
if (usedOutput >= bufferOutputSize)
{
bufferOutputSize += 10;
outputElement = (char*)checked_realloc(outputElement, bufferOutputSize);
}
if (usedOutput == 0)
error(1, 0, "Line %d: No input after '<'", __LINE__);
outputElement[usedOutput] = '\0';
usedOutput++;
//i--; //Check logic
}
i--;
}
/////CHECK FOR EXTRA i++!!!!!
//Case of '>' first
else
if (buffer[i] == '>')
{
int k = i;
while (buffer[k-1] == ' ')
{
k--;
if(buffer[k-1] == '\n')
error(1, 0, "Line %d: Operator and word on diff lines", __LINE__);
}
if (wordElement[0][0] == '\0')
error(1, 0, "Line %d: No command given to '<'", __LINE__);
i++;
while (buffer[i] != '<' && buffer[i] != '>' && buffer[i] != '&' && buffer[i] != '|' && buffer[i] != '(' && buffer[i] != ')' && buffer[i] != ';' && buffer[i] != '\n')
{
if (i == filled)
{
if (DEBUG) printf("471 Complete Command, free buffer at EOF");
currWord++;
wordElement[currWord] = '\0';
if (usedInput == 0)
inputElement = NULL;
if (usedOutput == 0)
outputElement = NULL;
makeSimpleCommand(wordElement, inputElement, outputElement);
completeCommand();
//free(buffer);
return headStream;
}
if (buffer[i] == ' ')
i++;
else
{
if (usedOutput >= bufferOutputSize)
{
bufferOutputSize += 10;
outputElement = (char*)checked_realloc(outputElement, bufferOutputSize);
}
outputElement[usedOutput] = buffer[i];
usedOutput++;
i++;
}
}
if (usedOutput >= bufferOutputSize)
{
bufferOutputSize += 10;
outputElement = (char*)checked_realloc(outputElement, bufferOutputSize);
}
if (usedOutput == 0)
error(1, 0, "Line %d: No input after '<'", __LINE__);
outputElement[usedOutput] = '\0';
usedOutput++;
if (buffer[i] == '<')
{
i++;
while (buffer[i] != '<' && buffer[i] != '>' && buffer[i] != '&' && buffer[i] != '|' && buffer[i] != '(' && buffer[i] != ')' && buffer[i] != ';' && buffer[i] != '\n')
{
if (i == filled)
{
if (DEBUG) printf("505 Complete Command, free buffer at EOF");
currWord++;
wordElement[currWord] = '\0';
if (usedInput == 0)
inputElement = NULL;
if (usedOutput == 0)
outputElement = NULL;
makeSimpleCommand(wordElement, inputElement, outputElement);
completeCommand();
//free(buffer);
return headStream;
}
if (buffer[i] == ' ')
i++;
else
{
if (usedInput >= bufferInputSize)
{
bufferInputSize += 10;
inputElement = (char*)checked_realloc(inputElement, bufferInputSize);
}
inputElement[usedInput] = buffer[i];
usedInput++;
i++;
}
}
if (usedInput >= bufferInputSize)
{
bufferInputSize += 10;
inputElement = (char*)checked_realloc(inputElement, bufferInputSize);
}
if (usedInput == 0)
error(1, 0, "Line %d: No input after '<'", __LINE__);
inputElement[usedInput] = '\0';
usedInput++;
}
wordElement[currWord + 1] = '\0';
/*if (usedInput == 0)
inputElement = NULL;
if (usedOutput == 0)
outputElement = NULL;
if(DEBUG) printf("makeSimpleCommand %s\n", wordElement[0]);
makeSimpleCommand(wordElement, inputElement, outputElement);
bufferWordSize = 10;
currWord = 0;
usedWord = 0;
usedInput = 0;
usedOutput = 0;
wordElement = (char**)checked_malloc(sizeof(char*));
wordElement[currWord] = (char*)checked_malloc(bufferWordSize);
inputElement = (char*)checked_malloc(bufferInputSize);
outputElement = (char*)checked_malloc(bufferOutputSize);*/
i--;
}
//Operators
//After every operator is encountered, use makeSimpleCommand to push the command on the stack
//Case of '|'
else
if (buffer[i] == '|')
{
int k = i;
while (buffer[k-1] == ' ')
{
k--;
if(buffer[k-1] == '\n')
error(1, 0, "Line %d: Operator and word on diff lines", __LINE__);
}
if (buffer[i+1] == '|' && operatorStack == NULL)
error(1, 0, "Line %d: Missing pipe for '||'", __LINE__);
if (wordElement[0][0] == '\0')
error(1, 0, "Line %d: Nothing for '|'", __LINE__);
//if (commandStack == NULL)
// error(1, 0, "Line %d: Nothing to run '|' on");
if (buffer[i + 1] == '|' && buffer[i+2] == '|')
error(1, 0, "Line %d: Invalid Command, too many '|'", i);
op = numberOfOper(&buffer[i]);
//error(1, 0, "Line %d: Nothing to pipe", __LINE__);
if (buffer[i-1] != ' ')
currWord++;
wordElement[currWord] = '\0';
if (usedInput == 0)
inputElement = NULL;
if (usedOutput == 0)
outputElement = NULL;
if (DEBUG) printf(" 566 makeSimpleCommand %s\n", wordElement[0]);
makeSimpleCommand(wordElement, inputElement, outputElement);
bufferWordSize = 10;
currWord = 0;
usedWord = 0;
usedInput = 0;
usedOutput = 0;
wordElement = (char**)checked_malloc(sizeof(char*));
wordElement[currWord] = (char*)checked_malloc(bufferWordSize);
inputElement = (char*)checked_malloc(bufferInputSize);
outputElement = (char*)checked_malloc(bufferOutputSize);
if (DEBUG) printf("577 Process operator %d\n", op);
processOperator(op);
if (op == 3)
i++;
if (buffer[i + 1] == ' ')
i++;
//i++;
}
//Case of '&'
else
if (buffer[i] == '&')
{
int k = i;
while (buffer[k-1] == ' ')
{
k--;
if(buffer[k-1] == '\n')
error(1, 0, "Line %d: Operator and word on diff lines", __LINE__);
}
//if (buffer[i] == '&' && operatorStack == NULL)
// error(1, 0, "Line %d: Missing pipe for '&&'", __LINE__);
if (wordElement[0][0] == '\0')
error(1, 0, "Line %d: Nothing for '|'", __LINE__);
if (buffer[i + 1] == '&' && buffer[i+2] == '&')
error(1, 0, "Line %d: Invalid Command, too many '&'", i);
op = numberOfOper(&buffer[i]);
if (buffer[i-1] != ' ')
currWord++;
wordElement[currWord] = '\0';
if (usedInput == 0)
inputElement = NULL;
if (usedOutput == 0)
outputElement = NULL;
if (DEBUG) printf("592 makeSimpleCommand %s\n", wordElement[0]);
makeSimpleCommand(wordElement, inputElement, outputElement);
bufferWordSize = 10;
usedWord = 0;
currWord = 0;
usedInput = 0;
usedOutput = 0;
wordElement = (char**)checked_malloc(sizeof(char*));
wordElement[currWord] = (char*)checked_malloc(bufferWordSize);
inputElement = (char*)checked_malloc(bufferInputSize);
outputElement = (char*)checked_malloc(bufferOutputSize);
processOperator(op);
i++;
if (buffer[i + 1] == ' ')
i++;
}
//Case of ';'
else
if (buffer[i] == ';')
{
int k = i;
while (buffer[k-1] == ' ')
{
k--;
if(buffer[k-1] == '\n')
error(1, 0, "Line %d: Operator and word on diff lines", __LINE__);
}
if(wordElement[0][0] == '\0')
error(1, 0, "Line %d: Nothing before sequence", i);
op = numberOfOper(&buffer[i]);
currWord++;
wordElement[currWord] = '\0';
if (usedInput == 0)
inputElement = NULL;
if (usedOutput == 0)
outputElement = NULL;
if (DEBUG) printf("617 makeSimpleCommand %s\n", wordElement[0]);
if ((currWord = 0) || (currWord == 1))
error(1, 0, "Line %d: Nothing to run ';' on", i);
makeSimpleCommand(wordElement, inputElement, outputElement);
bufferWordSize = 10;
usedWord = 0;
currWord = 0;
usedInput = 0;
usedOutput = 0;
wordElement = (char**)checked_malloc(sizeof(char*));
wordElement[currWord] = (char*)checked_malloc(bufferWordSize);
inputElement = (char*)checked_malloc(bufferInputSize);
outputElement = (char*)checked_malloc(bufferOutputSize);
processOperator(op);
//i++;
}
//Case of '\n'
else
if (buffer[i] == '\n' && i != 0)
{
/*int scChecker = i;
while (buffer[i + 1] == ' ')
{
scChecker++;
if (buffer[scChecker + 1] == ';')
error(1, 0, "Line %d: Newline followed by ';'");
}*/
if (buffer[i+1] == ';')
error(1, 0, "Line %d: Newline followed by ';'", i);
if ((i + 1) == (int)filled)
{
currWord++;
wordElement[currWord] = '\0';
if (usedInput == 0)
inputElement = NULL;
if (usedOutput == 0)
outputElement = NULL;
if (DEBUG) printf("654 makeSimpleCommand %s\n", wordElement[0]);
makeSimpleCommand(wordElement, inputElement, outputElement);
bufferWordSize = 10;
currWord = 0;
usedWord = 0;
usedInput = 0;
usedOutput = 0;
wordElement = (char**)checked_malloc(sizeof(char*));
wordElement[currWord] = (char*)checked_malloc(bufferWordSize);
inputElement = (char*)checked_malloc(bufferInputSize);
outputElement = (char*)checked_malloc(bufferOutputSize);
completeCommand();
free(buffer);
return headStream;
}
char lastC;
int back = 1;
while (buffer[i - back] == ' ' && i - back >= 0)
{
//lastC = buffer[i - back];
back++;
}
lastC = buffer[i - back];
if (buffer[i + 1] == '\n')
{
while (buffer[i + 1] == '\n')
i++;
if (lastC != '|' && lastC != '&')
{
currWord++;
wordElement[currWord] = '\0';
if (usedInput == 0)
inputElement = NULL;
if (usedOutput == 0)
outputElement = NULL;
if (DEBUG) printf("654 makeSimpleCommand %s\n", wordElement[0]);
makeSimpleCommand(wordElement, inputElement, outputElement);
bufferWordSize = 10;
currWord = 0;
usedWord = 0;
usedInput = 0;
usedOutput = 0;
wordElement = (char**)checked_malloc(sizeof(char*));
wordElement[currWord] = (char*)checked_malloc(bufferWordSize);
inputElement = (char*)checked_malloc(bufferInputSize);
outputElement = (char*)checked_malloc(bufferOutputSize);
completeCommand();
}
}
else
{
if (lastC == '|' || lastC == '&' || lastC == '<' || lastC || '>')
{
while (buffer[i + 1] == '\n')
i++;//////SPIT ERROR?
}
else
{
char swap = ';';
op = numberOfOper(&swap);
wordElement[currWord + 1] = '\0';
if (usedInput == 0)
inputElement = NULL;
if (usedOutput == 0)
outputElement = NULL;
if (DEBUG) printf(" 679 makeSimpleCommand %s\n", wordElement[0]);
makeSimpleCommand(wordElement, inputElement, outputElement);
bufferWordSize = 10;
currWord = 0;
usedWord = 0;
usedInput = 0;
usedOutput = 0;
wordElement = (char**)checked_malloc(sizeof(char*));
wordElement[currWord] = (char*)checked_malloc(bufferWordSize);
inputElement = (char*)checked_malloc(bufferInputSize);
outputElement = (char*)checked_malloc(bufferOutputSize);
processOperator(op);
}
}
}
//Case of # (comment)
else
if (buffer[i] == '#')
{
if (DEBUG) printf("698 Got a comment!\n");
while (buffer[i] != '\n')
i++;
}
//Else
else
{
if (buffer[i] == '\'')
{
if (buffer[i + 1] == 'E' && buffer[i + 2] == 'O' && buffer[i + 3] == 'F')
break;
}
//if (buffer[i] != ' ')
wordElement[currWord][usedWord] = buffer[i];
usedWord++;
if (i + 1 == filled)
{
currWord++;
wordElement[currWord] = '\0';
if (usedInput == 0)
inputElement = NULL;
if (usedOutput == 0)
outputElement = NULL;
makeSimpleCommand(wordElement, inputElement, outputElement);
completeCommand();
}
}
i++;
}
free(buffer);
return headStream;
}
int encrypt_file(const char *file, struct lfsr *l_17, struct lfsr *l_25, const char *outfile, int *dMode, unsigned char initialization_vector)
{
//File Manipulation
FILE *inFile = fopen(file, "rb");
if(inFile == NULL){
fprintf(stderr, "Error Opening File For Reading <%s>\n", file);
return -1;
}
FILE *oFile = fopen(outfile, "wb+");
if(oFile == NULL){
fprintf(stderr, "Error Opening File For Writing <%s>\n", outfile);
fclose(inFile);
return -2;
}
long lSize;
unsigned char *buffer = NULL;
size_t result;
fseek (inFile , 0 , SEEK_END);
lSize = ftell (inFile);
rewind (inFile);
buffer = (unsigned char*) malloc( sizeof(unsigned char) * lSize);
if (buffer == NULL) {
fprintf(stderr, "Memory Error While Reading File <%s>\n", file);
return -3;
}
result = fread (buffer, sizeof(unsigned char), lSize, inFile);
if (result != lSize) {
fprintf(stderr, "Error reading File into Memory <%s>\n", file);
return -4;
}
//Encryption
BIT byte_17[8], byte_25[8];
BIT carry = ZERO;
BIT sumArray[8] = {ZERO, ZERO, ZERO, ZERO,ZERO, ZERO, ZERO, ZERO};
int i;
unsigned char temp_keystream,
temp_plaintext,
temp_ciphertext;
/* MODES OF OPERATION:
ECB: mode = 0
CBC: 1
OFB: 2
CFB: 3
*/
MODE _mode = *dMode;
for(i=0; i<lSize; i++){
get_next_byte(l_17, byte_17);
get_next_byte(l_25, byte_25);
sum_bytes(byte_17, byte_25, carry, sumArray, &carry);
bit_array_to_unsigned_char(sumArray, &temp_keystream);
memcpy(&temp_plaintext, buffer+i, sizeof(unsigned char));
switch (_mode) {
case ECB:
temp_ciphertext = temp_keystream ^ temp_plaintext;
break;
case CBC:
temp_plaintext ^= initialization_vector;
temp_ciphertext = temp_keystream ^ temp_plaintext;
initialization_vector = temp_ciphertext;
break;
case OFB:
temp_ciphertext = temp_keystream ^ initialization_vector;
initialization_vector = temp_ciphertext;
temp_ciphertext ^= temp_plaintext;
break;
case CFB:
temp_ciphertext = temp_keystream ^ initialization_vector;
temp_ciphertext ^= temp_plaintext;
initialization_vector = temp_ciphertext;
break;
}
//Output the ciphertext to the File
if(fwrite (&temp_ciphertext , sizeof(unsigned char), 1, oFile) < 1){
fprintf(stderr, "Error Writing (%c) at index.(%d) to Output File <%s>, Aborting.\n", temp_ciphertext, i, outfile);
return -5;
}
}
fclose(inFile);
fclose(oFile);
return 0;
}
command_stream_t
make_command_stream (int (*get_next_byte) (void *),
void *get_next_byte_argument)
{
//current character
char curr;
int tree_number = 1;
char prev_char_stored = '\0';
int consecutive_newlines = 0;
//buffer size = 1KB
int BUFFER_SIZE = 1024;
//buffer to read characters into; buffer can hold 1024 chars at once
char *buffer = (char *) checked_malloc(BUFFER_SIZE * sizeof(char));
//int to count how many chars are in buffer
int numChars = 0;
//int to count which line we are on
//int syntax_line_counter = 0;
int invalid_char_line_counter = 1;
//if this is true, we are searching for the right operand of an operator
bool found_AND_OR_PIPE_SEQUENCE = false; //looking for operand
//declare command stream and allocate space
//maybe dont need to allocate space because initStream() already does?
command_stream_t theStream; // = (command_stream_t) checked_malloc(sizeof(struct command_stream));
//initialize command_stream
theStream = initStream();
//start reading the chars from the input
while ((curr = get_next_byte(get_next_byte_argument)) != EOF ) {
if (numChars > 0){
//only stores previous meaningful character, i.e. not whitespace
if ((buffer[numChars-1] != ' ' && buffer[numChars-1] != '#')){
prev_char_stored = buffer[numChars-1];
}
}
if (prev_char_stored == '&' || prev_char_stored == '|' || prev_char_stored == ';'){
found_AND_OR_PIPE_SEQUENCE = true;
}
////////////////////////////////////////////////////////////
////////////////// NEWLINE CHAR ////////////////////
////////////////////////////////////////////////////////////
/*
New variables introduced:
char prev_char_stored;
int consecutive_newlines;
bool command_has_ended; //haven't needed to use yet
*/
if (identify_char_type(curr) == NEWLINE_CHAR || identify_char_type(curr) == HASHTAG_CHAR){
//found a newline, increment counter
consecutive_newlines++;
//hit second (or more) newline
if (consecutive_newlines > 1){
//not looking for an operator and
if (!found_AND_OR_PIPE_SEQUENCE){
if (identify_char_type(curr) == NEWLINE_CHAR) {
//add second newline to buffer
buffer[numChars] = '\n';
numChars++;
curr = get_next_byte(get_next_byte_argument);
}
/*
check for newlines, whitespaces, and hashtags after second newline
Store newlines on the buffer, ignore white spaces, and for hashtags:
put hashtag and newline on the buffer
*/
while (identify_char_type(curr) == NEWLINE_CHAR || identify_char_type(curr) == WHITESPACE_CHAR || identify_char_type(curr) == HASHTAG_CHAR){
if (curr == '\n'){
buffer[numChars] = '\n';
numChars++;
} else if (curr == '#'){
//add hashtag to buffer
consecutive_newlines++;
buffer[numChars] = '#';
numChars++;
//go to end of comment
while (identify_char_type(curr) != NEWLINE_CHAR){
if ((curr = get_next_byte(get_next_byte_argument)) == EOF) {
break;
}
}
//broke out of loop, curr is now a newline char; add to buffer
buffer[numChars] = '\n';
numChars++;
}
if ((curr = get_next_byte(get_next_byte_argument)) == EOF) {
break;
}
}
consecutive_newlines = 0;
//create temporary array with size of numChars;
char* buffer_no_whitespaces = checked_malloc(BUFFER_SIZE * (sizeof(char))); //the correct syntaxed command
memset(buffer_no_whitespaces, '\0', BUFFER_SIZE * sizeof(char));
//run validation, then parse if correct
eatWhiteSpaces(buffer, numChars, buffer_no_whitespaces);
int pos = 0;
while (buffer_no_whitespaces[pos] != '\0'){
if (identify_char_type(buffer_no_whitespaces[pos]) == NEWLINE_CHAR){
invalid_char_line_counter++;
}
if (identify_char_type(buffer_no_whitespaces[pos]) == INVALID_CHAR){
identify_char_type(buffer_no_whitespaces[pos]);
fprintf(stderr, "%d: Invalid character: %c <---", invalid_char_line_counter, buffer_no_whitespaces[pos]);
exit(1);
}
pos++;
}
checkAndSyntax(buffer_no_whitespaces);
checkForConsecutiveTokens(buffer_no_whitespaces);
checkIfOperatorsHaveOperands(buffer_no_whitespaces);
validParentheses(buffer_no_whitespaces);
/*
int i;
for (i= 0; i<numChars; i++){
printf("%c", buffer_no_whitespaces[i]);
}
//this just separates commands
printf("\n");
*/
commandNode_t root = createNodeFromCommand(make_command_tree(buffer_no_whitespaces));
//printf("adding command node to stream: %s\n", root->cmd->u.word[0]);
write_list_t write_list = init_write_list();
//printf("adding command node to stream: %s\n", root->cmd->u.word[0]);
root->write_list = make_write_list(write_list, root->cmd);
read_list_t read_list = init_read_list();
root->read_list = make_read_list(read_list, root->cmd);
root->tree_number=tree_number;
root->dependency_list = (commandNode_t*)(checked_realloc(root->dependency_list, (tree_number) * sizeof(commandNode_t)));
memset (root -> dependency_list, '\0', (tree_number) * sizeof(commandNode_t));
//printf("adding command node to stream: %s\n", root->cmd->u.word[0]);
addNodeToStream(theStream, root);
//reset everything with memset
memset(buffer, '\0', BUFFER_SIZE * sizeof(char));
free(buffer_no_whitespaces);
numChars = 0;
consecutive_newlines = 0;
tree_number++;
if (curr == EOF)
break;
/*
We are now at a new command.
Add first character to buffer, whether valid or invalid.
Will check syntax later.
*/
if (identify_char_type(curr) != HASHTAG_CHAR){
buffer[numChars] = curr;
numChars++;
} else {
//add a hashtag and newline to the buffer
buffer[numChars] = '#';
numChars++;
//get to the end of the line
while (identify_char_type(curr) != NEWLINE_CHAR){
if ((curr = get_next_byte(get_next_byte_argument)) == EOF) {
break;
}
}
//now we have a newline; add newline to buffer
buffer[numChars]=curr;
numChars++;
consecutive_newlines++;
}
continue;
} else { //if we are looking for operand, don't end the commmand
while (identify_char_type(curr) == NEWLINE_CHAR || identify_char_type(curr) == WHITESPACE_CHAR || identify_char_type(curr) == HASHTAG_CHAR){
if (curr == '\n'){
buffer[numChars] = '\n';
numChars++;
} else if (curr == '#'){
//add hashtag to buffer
buffer[numChars] = '#';
numChars++;
while (identify_char_type(curr) != NEWLINE_CHAR){
if ((curr = get_next_byte(get_next_byte_argument)) == EOF) {
break;
}
}
//broke out of loop, curr is now a newline char; add to buffer
buffer[numChars] = '\n';
numChars++;
}
if ((curr = get_next_byte(get_next_byte_argument)) == EOF) {
break;
}
}
//broken out of while loop, we now have a regular character; add to buffer
if (curr == EOF)
break;
buffer[numChars] = curr;
numChars++;
found_AND_OR_PIPE_SEQUENCE = false;
consecutive_newlines = 0;
continue;
}
} else {
//add newline to buffer; this is when number of newlines equals one
if (identify_char_type(curr) == HASHTAG_CHAR) {
buffer[numChars] = '#';
numChars++;
while (identify_char_type(curr) != NEWLINE_CHAR){
if ((curr = get_next_byte(get_next_byte_argument)) == EOF) {
break;
}
}
}
buffer[numChars] = '\n';
numChars++;
continue;
}
} //end newline case
else {
if (!found_AND_OR_PIPE_SEQUENCE && consecutive_newlines == 1) {
buffer[numChars] = ';';
numChars++;
}
buffer[numChars] = curr;
numChars++;
consecutive_newlines = 0;
//if we are here we no longer skip lines
found_AND_OR_PIPE_SEQUENCE = false;
}
}
char* buffer_no_whitespaces = checked_malloc(BUFFER_SIZE * (sizeof(char))); //the correct syntaxed command
memset(buffer_no_whitespaces, '\0', BUFFER_SIZE * sizeof(char));
//run validation, then parse if correct
//void eatWhiteSpaces(char *buffer, int bufferSize, char *newArray)
eatWhiteSpaces(buffer, numChars, buffer_no_whitespaces);
int pos = 0;
while (buffer_no_whitespaces[pos] != '\0'){
if (identify_char_type(buffer_no_whitespaces[pos]) == NEWLINE_CHAR){
invalid_char_line_counter++;
}
if (identify_char_type(buffer_no_whitespaces[pos]) == INVALID_CHAR){
identify_char_type(buffer_no_whitespaces[pos]);
fprintf(stderr, "%d: Invalid character: %c <---", invalid_char_line_counter, buffer_no_whitespaces[pos]);
exit(1);
}
pos++;
}
checkAndSyntax(buffer_no_whitespaces);
checkForConsecutiveTokens(buffer_no_whitespaces);
checkIfOperatorsHaveOperands(buffer_no_whitespaces);
validParentheses(buffer_no_whitespaces);
/*
if (buffer_no_whitespaces[0] != '\0') {
int i;
for (i= 0; i<numChars; i++){
printf("%c", buffer_no_whitespaces[i]);
}
printf("\n");
}*/
//make sure buffer_no_whitespace is not empty
if (buffer_no_whitespaces[0] != '\0') {
commandNode_t root = createNodeFromCommand(make_command_tree(buffer_no_whitespaces));
write_list_t write_list = init_write_list();
root->write_list = make_write_list(write_list, root->cmd);
read_list_t read_list = init_read_list();
root->read_list = make_read_list(read_list, root->cmd);
root->tree_number=tree_number;
root->dependency_list = (commandNode_t*)(checked_realloc(root->dependency_list, (tree_number) * sizeof(commandNode_t)));
memset (root -> dependency_list, '\0', (tree_number) * sizeof(commandNode_t));
//printf("adding command node to stream: %s\n", root->cmd->u.word[0]);
addNodeToStream(theStream, root);
}
free(buffer);
free(buffer_no_whitespaces);
theStream->blocked_commands = (commandNode_t*)checked_realloc(theStream->blocked_commands, theStream->num_nodes * sizeof(commandNode_t));
memset(theStream->blocked_commands, '\0', theStream->num_nodes * sizeof(commandNode_t));
return theStream;
}
void
makeSeparation(FILE* fp, Separation_t* m_separation, int (*get_next_byte) (void *))
{
char* word[MAXLINE];
int atLine[MAXLINE];
char* str="";
char ch = get_next_byte(fp);
char preCh;
int countWord=0;
int countParath=0;
int countLine=1; //this parameter records the line number that the program is reading
int newLineFlag=1; //this flag is used to skip white space after '\n'
int newWordFlag=0;
int headFlag=1;
//Separation_t m_separation[MAXLINE];
//this while is to slit the text by 2 or more '\n' and the split results are stored in array word
while(ch!=EOF){
//this if is to skip white space after '\n'
if((ch==' '||ch=='\t') && newLineFlag) {ch=get_next_byte(fp);continue;}
//this if is to get rid of comment starting with '#', while the tailing '\n' is preserved
if(ch=='#'){
while(ch!='\n' && ch!=EOF){
ch=getc(fp);
}
countLine++;
ch=getc(fp);
continue;
}
//this if is to extract the subshell expressed as ()
if(ch=='('){
int badLine = countLine;
// printf("enter subshell: badLine=%d\n",badLine);
do{
if(ch=='#'){
while(ch!='\n' && ch!=EOF){
ch=getc(fp);
}
countLine++;
ch=getc(fp);
continue;
}
str = str_append(str,ch);
if(ch=='(') countParath++;
if(ch==')') countParath--;
if(ch=='\n') countLine++;
ch=getc(fp);
}while(countParath && ch!=EOF);
if(ch==EOF){
word[countWord]=checked_malloc(sizeof(str)+1);
memset(word[countWord],'\0',sizeof(str)+1);
word[countWord]=str;
atLine[countWord]=badLine;
countWord++;
str="";
break;
}
}
if(ch!='\n'){
str = str_append(str,ch);
newLineFlag=0;
if(headFlag){
atLine[0]=countLine;
headFlag=0;
}
}
else{
newLineFlag=1;
countLine++;
//printf("3:countLine=%d\n",countLine);
if(preCh=='\n' && strlen(str)>0){
word[countWord]=checked_malloc(sizeof(str)+1);
memset(word[countWord],'\0',sizeof(str)+1);
word[countWord]=str;
countWord++;
str="";
newWordFlag=1;
}
else if(strlen(str)>0){
str = str_append(str,ch);
if(newWordFlag){
atLine[countWord]=countLine-1;
newWordFlag=0;
}
if(headFlag){
atLine[0]=countLine;
headFlag=0;
}
}
//printf(" (%c at line %d, the str=%s, strlen=%d) ",ch,countLine,str, (int)strlen(str));
}
preCh=ch;
ch = get_next_byte(fp);
}
//if the last word doesn't end with "\n\n", also add it in
if(str!=""){
word[countWord]=checked_malloc(sizeof(str)+1);
memset(word[countWord],'\0',sizeof(str)+1);
word[countWord]=str;
countWord++;
newWordFlag=1;
}
//if the last word doesn't end with '\n', revise the bug of counting line
if(atLine[countWord-1]==0)
atLine[countWord-1]=countLine;
fclose(fp);
//==============end of read file====================
//============================merge word with tailing operator=======================================
int merge[countWord+1];
int i=0;
// for(i=0; i<countWord; i++){
// printf("word %d at Line %d is:\n%s",i,atLine[i],word[i]);
// }
// for(i=0; i<countWord; i++)
// printf("%d\n",atLine[i]);
//delete tailing '\n'
for(i=0; i<countWord; i++){
//get rid of tailing '\n'
size_t sz=strlen(word[i]);
if(word[i][sz-1]=='\n'){
word[i][sz-1]='\0';
sz--;
}
//printf("w%d:\n%s",i,word[i]);
//if ending with operator: '|' ';' '||' '&&' '<' '>', mark this word in array merge[]
if(word[i][sz-1]=='|' || word[i][sz-1]==';' || word[i][sz-1]=='<' || word[i][sz-1]=='>' || (word[i][sz-1]=='&' && word[i][sz-2]=='&'))
merge[i]=strlen(word[i]);
else
merge[i]=-strlen(word[i]);
//printf("merge[%d]=%d\n",i,merge[i]);
}
//printf("4:countLine=%d\n",countLine);
//recompute the total word in merged array
int newCountWord=0;
for(i=0; i<countWord; i++){
if(merge[i]<0) newCountWord++;
else{
newCountWord++;
while(merge[i]>0 && i<countWord) i++;
}
}
//printf("newCountWord=%d\n",newCountWord);
//merge and copy from old array to new array
char* commandStr[newCountWord];
int newAtLine[newCountWord];
int ptrOld=0;
int ptrNew=0;
while(ptrOld<countWord && ptrNew<newCountWord){
if(merge[ptrOld]<0) {
//printf("hi: %d\n",ptrOld);
commandStr[ptrNew] = checked_malloc(abs(merge[ptrOld])+1);
strcpy(commandStr[ptrNew],word[ptrOld]);
newAtLine[ptrNew]=atLine[ptrOld];
}
else {
int startPtr=ptrOld;
size_t cpyLen=0;
while(merge[ptrOld]>0 && ptrOld<countWord){
cpyLen+=merge[ptrOld];
ptrOld++;
}
if(ptrOld==countWord){
//printf("\n\nhuge bug!!!\n\n");
//printf("\ncpyLen=%d\n\n",(int)cpyLen);
commandStr[ptrNew] = checked_malloc(cpyLen+1);
memset(commandStr[ptrNew],'\0',cpyLen+1);
newAtLine[ptrNew]=atLine[startPtr];
while(startPtr<=--ptrOld){
strcat(commandStr[ptrNew],word[startPtr]);
startPtr++;
}
break;
}
cpyLen+=abs(merge[ptrOld]);
//printf("\ncpyLen=%d\n\n",(int)cpyLen);
commandStr[ptrNew] = checked_malloc(cpyLen+1);
memset(commandStr[ptrNew],'\0',cpyLen+1);
newAtLine[ptrNew]=atLine[startPtr];
while(startPtr<=ptrOld){
strcat(commandStr[ptrNew],word[startPtr]);
startPtr++;
}
}
ptrNew++;
ptrOld++;
}
for(i=0;i<newCountWord;i++){
//printf("1111: CMD%d at line %d is:\n%s",i,newAtLine[i],commandStr[i]);
m_separation[i]=checked_malloc(sizeof(Separation));
m_separation[i]->m_cmd = checked_malloc(strlen(commandStr[i])+1);
strcpy(m_separation[i]->m_cmd,commandStr[i]);
m_separation[i]->m_line=newAtLine[i];
//printf("CMD%d at line %d is:\n%s",i,m_separation[i]->m_line,m_separation[i]->m_cmd);
}
//write an end indicating element
m_separation[newCountWord]=checked_malloc(sizeof(Separation));
m_separation[newCountWord]->m_cmd=checked_malloc(strlen("this is the end")+1);
strcpy(m_separation[newCountWord]->m_cmd, "this is the end");
m_separation[newCountWord]->m_line=-1;
//=================================end of merge word======================================================
//return m_separation;
}
command_stream_t main()
{
char* script_name = "test.sh";
FILE *script_stream = fopen (script_name, "r");
int buffer_size=1000;
char* buffer = (char* )malloc(buffer_size);
size_t count = 0;
char ch;
do
{
ch = get_next_byte(script_stream);
if (ch == '#') // for comments: ignore everything until '\n' or EOF
{
ch = get_next_byte(script_stream);
while(ch != EOF && ch!='\n')
ch = get_next_byte(script_stream);
}
//skip all the words until \n
if (ch!= -1)
{
// load into buffer
buffer[count] = ch;
count++;
// expand buffer if necessary
//if (count == INT_MAX)
//{
// error(1, 0, "Line -1: Input size over INT_MAX.");
//}
if (count == buffer_size)
{
buffer_size = buffer_size * 2;
buffer = (char*)realloc (buffer, buffer_size);
}
}
} while(ch != -1);
//token_stream_t return_point =convert_buffer_to_token_stream(buffer, count);
//printf("convert end\n");
token_stream_t return_token_stream = convert_buffer_to_token_stream(buffer, count);
/* if(return_token_stream==NULL)
printf("NULL pointer\n");
else
{
if(return_token_stream->head == NULL)
printf("NULL head\n");
else
{
printf("head is not null\n" );
printf("%d\n",return_token_stream->head->t_type);
printf("%c\n",return_token_stream->head->next->text[0]);
if(return_token_stream->head->next->next != NULL)
{
printf("linked");
printf("%d\n",return_token_stream->head->next->next->t_type);
}
}
}
if(return_token_stream->next==NULL)
printf("NEXT is NULL pointer\n");
else
{
if(return_token_stream->next->head == NULL)
printf("NEXT NULL head\n");
else
{
printf("head is not null\n" );
printf("%d\n",return_token_stream->next->head->t_type);
printf("%c\n",return_token_stream->next->head->next->text[0]);
if(return_token_stream->next->head->next->next->next == NULL)
printf("YEAH");
}
}
printf("main end");*/
command_t new_command_t = make_command_tree (return_token_stream);
printf("make tree end\n");
add_command_to_stream(new_command_t );
while (return_token_stream->next != NULL)
{
//make return_point point to next token stream
return_token_stream = return_token_stream->next;
//free(return_point);
//return_token_stream = temp;
new_command_t = make_command_tree (return_token_stream);
add_command_to_stream(new_command_t);
}
return command_stream_head;
}
command_stream_t
make_command_stream (int (*get_next_byte) (void *),
void *get_next_byte_argument)
{
/* FIXME: Replace this with your implementation. You may need to
add auxiliary functions and otherwise modify the source code.
You can also use external functions defined in the GNU C Library. */
// initialize memory allocation
// count of characters
int pt_count = 0;
int cmd_count = 0;
int i = 0;
char input_byte;
char prev_byte;
char *tmp = NULL;
char *tmp_ch = NULL;
command_stream t = { 0, 0, NULL };
command_stream_t result_stream = &t;
// Initalize memory allocation for stream
result_stream->command_list = (char**) malloc(sizeof(char**));
result_stream->command_list[0] = NULL;
// initialize stream
input_byte = (char)get_next_byte(get_next_byte_argument);
// Reallocate memory for stream characters
// Record stream
while (input_byte != EOF)
{
if (is_valid_op(input_byte, prev_byte))
{
// Add command
if (tmp_ch != NULL)
{
add_command(&(result_stream->command_list), pt_count++, &tmp_ch, cmd_count);
}
// Operator Cases
if (input_byte == '#')
{
// Append # comment to next command
tmp_ch = (char*) malloc(sizeof(char));
tmp_ch[0] = input_byte;
}
else if (input_byte == '|' && prev_byte != '|')
{
printf("hello");
}
else if (input_byte != '|' && prev_byte == '|')
{
// Add operator
tmp = (char*) malloc(sizeof(char));
tmp[0] = prev_byte;
add_command(&(result_stream->command_list), pt_count++, &tmp, 1);
}
else if (input_byte == '|' && prev_byte == '|')
{
// Add operator
tmp = (char*) malloc(2*sizeof(char));
tmp[0] = input_byte;
tmp[1] = prev_byte;
add_command(&(result_stream->command_list), pt_count++, &tmp, 2);
// prevent from being read again
input_byte = ' ';
}
else if (input_byte == '&' && prev_byte != '&')
{
}
else if (input_byte != '&' && prev_byte == '&')
{
// Add operator
tmp = (char*) malloc(sizeof(char));
tmp[0] = input_byte;
add_command(&(result_stream->command_list), pt_count++, &tmp, 1);
}
else if (input_byte == '&' && prev_byte == '&')
{
// Add operator
tmp = (char*) malloc(2*sizeof(char));
tmp[0] = input_byte;
tmp[1] = prev_byte;
add_command(&(result_stream->command_list), pt_count++, &tmp, 2);
// prevent from being read again
input_byte = ' ';
}
else
{
// Add operator
tmp = (char*) malloc(sizeof(char));
tmp[0] = input_byte;
add_command(&(result_stream->command_list), pt_count++, &tmp, 1);
}
// Reset for next add
if(input_byte == '#')
{
cmd_count = 1;
}
else
{
cmd_count = 0;
}
prev_byte = input_byte;
input_byte = get_next_byte(get_next_byte_argument);
continue;
}
if (input_byte == '#')
{
// Reset
prev_byte = input_byte;
input_byte = get_next_byte(get_next_byte_argument);
continue;
}
// Allocate for command until delimiter found
tmp_ch = (char*) realloc(tmp_ch, (cmd_count+1)*sizeof(char));
tmp_ch[cmd_count] = input_byte;
cmd_count++;
prev_byte = input_byte;
input_byte = get_next_byte(get_next_byte_argument);
}
result_stream->size = pt_count;
// Test print
for (i=0; i < pt_count; i++)
{
printf("%d: %s\n", i, result_stream->command_list[i]);
}
printf("\npt_count: %d \n", pt_count);
// Returns stream as character array
return result_stream;
}
command_stream_t
make_command_stream (int (*get_next_byte) (void *),
void *get_next_byte_argument)
{
/* FIXME: Replace this with your implementation. You may need to
add auxiliary functions and otherwise modify the source code.
You can also use external functions defined in the GNU C Library. */
size_t buffer_size=1000;
char* buffer = (char* )checked_malloc(buffer_size);
size_t count = 0;
char ch;
do
{
ch = get_next_byte(get_next_byte_argument);
if (ch == '#') // for comments: ignore everything until '\n' or EOF
{
ch = get_next_byte(get_next_byte_argument);
while(ch != EOF && ch!='\n')
ch = get_next_byte(get_next_byte_argument);
}
//skip all the words until \n
if (ch!= -1)
{
// load into buffer
buffer[count] = ch;
count++;
// expand buffer if necessary
//if (count == INT_MAX)
//{
// error(1, 0, "Line -1: Input size over INT_MAX.");
//}
if (count == buffer_size)
{
buffer_size = buffer_size * 2;
buffer = (char*)checked_realloc (buffer, buffer_size);
}
}
} while(ch != -1);
token_stream_t return_token_stream = convert_buffer_to_token_stream(buffer, count);
command_t new_command_t = make_command_tree (return_token_stream);
// printf("make tree end\n");
add_command_to_stream(new_command_t );
// printf("add first command to stream\n");
// printf("command type : %d\n", new_command_t->type);
//if(new_command_t == NULL)
// printf("HAHA");
// print_command(new_command_t);
while (return_token_stream->next != NULL)
{
//make return_point point to next token stream
return_token_stream = return_token_stream->next;
//free(return_point);
//return_token_stream = temp;
new_command_t = make_command_tree (return_token_stream);
add_command_to_stream(new_command_t);
// printf("add another command to stream\n");
//print_command(new_command_t);
}
// printf("return to main\n");
// print_command()
return command_stream_head;
}
static uint8_t get_next_control(decompression_state *state)
{
uint8_t c = get_next_byte(state);
/* OC_DEBUG(3, "control: 0x%02x", c); */
return c;
}
command_stream_t
make_command_stream (int (*get_next_byte) (void *),
void *get_next_byte_argument)
{
//*****************************************
// CREATE & ALLOCATE BUFFER
//*****************************************
int current_size = 1024;
char* buffer = (char*)checked_malloc(sizeof(char)*current_size);
int byte_count = 0;
for(;;) {
int c = get_next_byte(get_next_byte_argument);
if (byte_count == current_size) {
current_size = current_size*2;
size_t size_size = sizeof(char)*current_size;
buffer = (char*)checked_grow_alloc((void*)buffer, &(size_size));
}
if (c != EOF && byte_count < current_size) {
buffer[byte_count] = c;
byte_count++;
}
else
break;
}
//*****************************************
// MAKE COMMAND STREAM OF COMMAND NODES
//*****************************************
int currentPos = 0;
int lineNum = 1;
// initialize command stream
command_stream_t command_stream = checked_malloc(sizeof(struct command_stream));
// initialize first node
command_node_t firstCommandNode = checked_malloc(sizeof(struct command_node));
command_stream->current_node = firstCommandNode;
command_node_t currentCommandNode = command_stream->current_node;
// initialize first command
command_t firstCommand = checked_malloc(sizeof(struct command));
firstCommandNode->command = firstCommand;
command_t currentCommand = currentCommandNode->command;
while (get_command(buffer, ¤tPos, byte_count, currentCommand, &lineNum) == 1) {
// create new node
command_node_t newCommandNode = checked_malloc(sizeof(struct command_node));
newCommandNode->prev = currentCommandNode;
currentCommandNode->next = newCommandNode;
currentCommandNode = currentCommandNode->next;
// create new command for that node
command_t newCommand = checked_malloc(sizeof(struct command));
newCommandNode->command = newCommand;
currentCommand = currentCommandNode->command;
}
if (currentCommandNode->prev != NULL) // couldn't add first command
currentCommandNode->prev->next = NULL;
else
command_stream->current_node = NULL;
return command_stream;
}
