/*
* Reads the tokens from the file into an array which is returned via
* the 'ary' parameter. The caller is responsable for freeing the
* array.
*
* Returns 0 on success and 1 on failure.
*/
static int read_token_array(FILE * f, char **ary, unsigned int *n){
struct list_node *head, *p;
unsigned int i;
char *a;
head = read_token_list(f, n);
if (!head)
return 1;
a = malloc(sizeof(*a) * *n);
if (!a) {
perror("malloc failed");
free_token_list(head);
return 1;
}
i = *n - 1;
p = head;
while (p) {
a[i] = p->val;
p = p->next;
i -= 1;
}
*ary = a;
free_token_list(head);
return 0;
}
t_parse *ft_checking_syntax(t_token *tok)
{
tok = inibitor_handler(tok);
return_type_quoted(tok);
tok = join_quoted(tok, QUOTES);
tok = join_quoted(tok, SINGLE_QUOTES);
tok = ft_subshell(tok);
tok = check_dollar(tok);
tok = ft_tild_expand(tok);
ft_edit_useless(tok);
if ((tok = ft_token_removal(tok, QUOTES)) == NULL)
return (NULL);
if ((tok = ft_token_removal(tok, SINGLE_QUOTES)) == NULL)
return (NULL);
tok = join_tokens(tok);
if ((tok = ft_token_removal(tok, WHITESPACE)) == NULL)
return (NULL);
if (!tok)
return (NULL);
if (!(ft_command_isvalid(tok)))
{
free_token_list(tok);
return (NULL);
}
return (parse_build_list(tok));
}
/* attempts to open a file, tokenize and then process it as a haserl script */
int
h_lua_loadfile (lua_State * L)
{
script_t *scriptchain;
token_t *tokenchain;
buffer_t script_text;
int status;
/* get the filename */
const char *filename = luaL_checkstring (L, 1);
scriptchain = load_script ((char *) filename, NULL);
tokenchain = build_token_list (scriptchain, NULL);
preprocess_token_list (tokenchain);
process_token_list (&script_text, tokenchain);
free_token_list (tokenchain);
free_script_list (scriptchain);
/* script_text has the include file */
status = luaL_loadbuffer (L, (char *) script_text.data,
script_text.ptr - script_text.data, filename);
buffer_destroy (&script_text);
if (status)
{
lua_error (L);
}
return (1); /* we return one value, the buffer, as a function */
}
/*
* Reads the tokens from a file into a linked list. Returns the size
* of the list via the 'num' parameter. The caller is responsable for
* freeing the list.
*
* Return NULL on failure;
*/
static struct list_node *read_token_list(FILE *f,
unsigned int *num){
int _num;
char c = '\0';
struct list_node *head = NULL;
_num = 0;
while ((c = getc(f)) != EOF) {
if (c != '\n' && c != '\t' && c != ' '){
struct list_node *n;
n = malloc(sizeof(*n));
if (!n) {
perror("malloc failed");
free_token_list(head);
return NULL;
}
n->val = c;
_num += 1;
n->next = head;
head = n;
}
}
*num = _num;
return head;
}
/*
*
* free_server - free a server and possibly its queues also
*
* sinfo - the server_info list head
* free_queues_too - flag to free the queues attached to server also
*
* returns nothing
*
*/
void free_server(server_info *sinfo, int free_objs_too)
{
if (sinfo == NULL)
return;
if (free_objs_too)
{
free_queues(sinfo -> queues, 1);
free_nodes(sinfo -> nodes);
}
free_token_list(sinfo -> tokens);
free_server_info(sinfo);
}
static void free_lines(t_file *file)
{
t_list *tmp;
t_list *next;
tmp = file->lines;
while (tmp)
{
next = tmp->next;
if (LINE->str)
free(LINE->str);
free_token_list(LINE->tokens);
free(LINE);
free(tmp);
tmp = next;
}
}
int main(void){
char buffer[MAXLINE];
printf("$ ");
while( fgets(buffer, MAXLINE, stdin) != NULL ){
if( buffer[strlen(buffer) - 1] == '\n' )
buffer[strlen(buffer) - 1] = '\0';
struct tokenized_node* tokenized_command = tokenize(buffer);
command* parsed_command =
create_parse_tree(tokenized_command);
#ifdef DEBUG
command* command_iterator;
for (iterator(command_iterator, parsed_command))
{
printf("New command:\n");
commanditem* command_contents = command_iterator->contents;
for (iter(command_contents))
{
printf("%s\n", (char*)(command_contents->contents));
}
if (command_iterator->input != NULL)
printf("\tInput: %s\n", command_iterator->input);
if (command_iterator->output != NULL)
printf("\tOutput: %s\n", command_iterator->output);
if (command_iterator->output_append)
printf("\tAppend\n");
if (command_iterator->background)
printf("\tBackground this\n");
}
#endif
execute(parsed_command);
free_parse_tree(parsed_command);
free_token_list(tokenized_command);
printf("$ ");
}
return 0;
}
void completely_free_fact_list(fact_list l)
{
fact_list temp;
while(l) { temp = l->next; free_token_list(l->item); free(l); l = temp;}
}
