modified: variable.c
[tiny-shell:tiny-shell.git] / variable.c
1 /*
2 * variable.c
3 * Copyright 2010-2011
4
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 3 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18 */
19
20 #include <stdio.h>
21 #include <string.h>
22 #include <stdlib.h>
23 #include <variable.h>
24
25 /* Deals with storing and retrieving of shell
26  * variables.
27  */
28
29 /* Function to initialize the list of shell
30  * variables.
31  */
32  void initList(VList *vlist){
33         vlist->node = NULL;
34         vlist->right = NULL;
35         vlist->left = NULL;
36  }
37
38  /* Function to add the tuple into the list.
39   * Arg0: Pointer to Variable List
40   * Arg1: Key
41   * Arg2: Value
42   * Return: 0 on success.
43   *         -1 on failure.
44   */
45
46  int addToList(VList *vlist,char *key,char *value){
47         VTuple *vtuple;
48         VList *new_vlist;
49         VList *vtemp;
50         int cmp_value;
51
52         /* Never trust anybody. Check the arguments. */
53         if(vlist == NULL || key == NULL || value == NULL){
54                 fprintf(stderr,"Error:Illegal arguments.\n \
55                                 addToList(VList*,char*,char*)");
56                 return -1;
57         }
58
59         vtuple = (VTuple*)malloc(sizeof(VTuple));       
60         if(vtuple == NULL){
61                 fprintf(stderr,"Error:Could not allocate memory.\n \
62                                 vtuple = (VTuple*)malloc(sizeof(VTuple))");     
63                 return -1;
64         }       
65
66         strcpy(vtuple->key,key);
67         strcpy(vtuple->value,value);
68
69         /* If it is the first element. */
70         if(vlist->node == NULL){
71                 vlist->node = vtuple;   
72                 return 0;
73         }
74
75         new_vlist = (VList*)malloc(sizeof(VList));      
76         if(new_vlist == NULL){
77                 fprintf(stderr,"Error:Could not allocate memory.\n \
78                                 vlist = (VList*)malloc(sizeof(VList))");        
79                 return -1;
80         }       
81         new_vlist->left = NULL;
82         new_vlist->right = NULL;
83         new_vlist->node = vtuple;
84
85         vtemp = vlist;
86         /* Find the entry first. */
87         while(1){
88                 cmp_value = strcmp(key,vtemp->node->key);
89                 if(cmp_value == 0){
90                         /* If we have a match then tuple must alredy be there.
91                          * We just edit it. Rather than create a new one. */
92                         free(vtemp->node);
93                         free(new_vlist);
94                         vtemp->node = vtuple;
95                         return 0;
96                 }
97                 else if(cmp_value < 0){                 /* Left branch. */
98                         if(vtemp->left==NULL){
99                                 vtemp->left = new_vlist;
100                                 return 0;
101                         }
102                         vtemp = vtemp->left;
103                 }
104                 else{
105                         if(vtemp->right==NULL){         /* Right branch. */
106                                 vtemp->right = new_vlist;
107                                 return 0;
108                         }
109                         vtemp = vtemp->right;
110                 }
111         }
112
113         return -1;
114  }
115
116  /* Function to return the value of the shell
117   * variable passed to it.
118   * Arg0: Pointer to Variable List
119   * Arg1: Key
120   * Arg2: Sets the value for the user.
121   * Return: 0 on success.
122   *         -1 on failure or if the tuple is not found.
123   */
124 int getVarValue(VList *vlist,char *key,char *value){
125
126         VList *vtemp;
127         int cmp_value;
128         char *buffer;
129
130         /* Never trust anybody. Check the arguments. */
131         if(vlist == NULL || key == NULL || value == NULL){
132                 fprintf(stderr,"Error:Illegal arguments.\n \
133                                 getVarValue(VList*,char*,char*)");
134                 return -1;
135         }               
136         
137         /* I wonder if binary tree is as tasty as banana tree. */ 
138         vtemp = vlist;
139         while(vtemp!=NULL && vtemp->node!=NULL){
140         cmp_value = strcmp(key,vtemp->node->key);
141                 if(cmp_value == 0){
142                         strcpy(value,vtemp->node->value);
143                         return 0;
144                 }
145                 else if(cmp_value < 0){
146                         vtemp = vtemp->left;
147                 }
148                 else{
149                         vtemp = vtemp->right;
150                 }
151         }
152
153         /* It might be an environment variable.
154          * The reason we check this in the end is because
155          * we give preference to local shell variables first.
156          */
157
158         if((buffer = getenv(key))!=NULL){
159                 strcpy(value,buffer);
160                 return 0;                       
161         }
162         /* Otherwise we could not even find it here also. */
163
164         return -1;
165 }