11 |
|
|
12 |
typedef struct stack_item |
typedef struct stack_item |
13 |
{ |
{ |
14 |
enum {value, string, ref, func, symbol} type; |
enum {value, string, ref, func, symbol, list} type; |
15 |
union { |
union { |
16 |
void* ptr; |
void* ptr; |
17 |
int val; |
int val; |
121 |
|
|
122 |
int push_ref(stackitem** stack_head, hashtbl in_hash, const char* in_string) |
int push_ref(stackitem** stack_head, hashtbl in_hash, const char* in_string) |
123 |
{ |
{ |
124 |
void* handle; |
static void* handle= NULL; |
125 |
void* symbol; |
void* symbol; |
126 |
|
|
127 |
stackitem* new_item= malloc(sizeof(stackitem)); |
stackitem* new_item= malloc(sizeof(stackitem)); |
128 |
new_item->content.ptr= *hash(in_hash, in_string); |
new_item->content.ptr= *hash(in_hash, in_string); |
129 |
new_item->type= ref; |
new_item->type= ref; |
130 |
|
|
131 |
if(new_item->content.ptr==NULL) { |
if(new_item->content.ptr==NULL) { |
132 |
handle= dlopen(NULL, RTLD_LAZY); |
if(handle==NULL) |
133 |
|
handle= dlopen(NULL, RTLD_LAZY); |
134 |
|
|
135 |
symbol= dlsym(handle, in_string); |
symbol= dlsym(handle, in_string); |
136 |
if(dlerror()==NULL) |
if(dlerror()==NULL) |
137 |
def_func(in_hash, symbol, in_string); |
def_func(in_hash, symbol, in_string); |
150 |
{ |
{ |
151 |
stackitem* temp= *stack_head; |
stackitem* temp= *stack_head; |
152 |
|
|
153 |
|
if((*stack_head)==NULL) |
154 |
|
return; |
155 |
|
|
156 |
|
if((*stack_head)->type==string) |
157 |
|
free((*stack_head)->content.ptr); |
158 |
|
|
159 |
*stack_head= (*stack_head)->next; |
*stack_head= (*stack_head)->next; |
160 |
free(temp); |
free(temp); |
161 |
} |
} |
162 |
|
|
163 |
|
extern void nl() |
164 |
|
{ |
165 |
|
printf("\n"); |
166 |
|
} |
167 |
|
|
168 |
/* print_stack(stack); */ |
void prin(stackitem** stack_head) |
169 |
void print_st(stackitem* stack_head, long counter) |
{ |
170 |
{ |
if((*stack_head)==NULL) |
171 |
if(stack_head->next != NULL) |
return; |
|
print_st(stack_head->next, counter+1); |
|
172 |
|
|
173 |
switch(stack_head->type){ |
switch((*stack_head)->type) { |
174 |
case value: |
case value: |
175 |
printf("%ld: %d\n", counter, (int)stack_head->content.val); |
printf("%d", (*stack_head)->content.val); |
176 |
break; |
break; |
177 |
case string: |
case string: |
178 |
printf("%ld: \"%s\"\n", counter, (char*)stack_head->content.ptr); |
printf("%s", (char*)(*stack_head)->content.ptr); |
179 |
break; |
break; |
180 |
case ref: |
case ref: |
181 |
case func: |
printf("%s", ((stackitem*)(*stack_head)->content.ptr)->id); |
182 |
|
break; |
183 |
case symbol: |
case symbol: |
184 |
printf("%ld: %p\n", counter, stack_head->content.ptr); |
default: |
185 |
|
printf("%p", (*stack_head)->content.ptr); |
186 |
break; |
break; |
187 |
} |
} |
188 |
} |
} |
189 |
|
|
190 |
|
extern void print(stackitem** stack_head) |
191 |
|
{ |
192 |
|
prin(stack_head); |
193 |
|
toss(stack_head); |
194 |
|
} |
195 |
|
|
196 |
|
/* print_stack(stack); */ |
197 |
|
void print_st(stackitem* stack_head, long counter) |
198 |
|
{ |
199 |
|
if(stack_head->next != NULL) |
200 |
|
print_st(stack_head->next, counter+1); |
201 |
|
|
202 |
|
printf("%ld: ", counter); |
203 |
|
prin(&stack_head); |
204 |
|
nl(); |
205 |
|
} |
206 |
|
|
207 |
extern void printstack(stackitem** stack_head) |
extern void printstack(stackitem** stack_head) |
208 |
{ |
{ |
209 |
if(*stack_head != NULL) { |
if(*stack_head != NULL) { |
261 |
return 1; |
return 1; |
262 |
} |
} |
263 |
|
|
264 |
extern void print(stackitem** stack_head) |
extern void pack(stackitem** stack_head) |
265 |
{ |
{ |
266 |
|
void* delimiter; |
267 |
|
stackitem *iterator, *temp, *pack; |
268 |
|
|
269 |
if((*stack_head)==NULL) |
if((*stack_head)==NULL) |
270 |
return; |
return; |
271 |
|
|
272 |
switch((*stack_head)->type){ |
delimiter= (*stack_head)->content.ptr; |
|
case value: |
|
|
printf("%d", (*stack_head)->content.val); |
|
|
break; |
|
|
case string: |
|
|
printf("%s", (char*)(*stack_head)->content.ptr); |
|
|
break; |
|
|
case symbol: |
|
|
printf("%s", (*stack_head)->id); |
|
|
case ref: |
|
|
default: |
|
|
printf("%p", (*stack_head)->content.ptr); |
|
|
break; |
|
|
} |
|
|
|
|
273 |
toss(stack_head); |
toss(stack_head); |
274 |
|
|
275 |
|
iterator= *stack_head; |
276 |
|
|
277 |
|
while(iterator->next!=NULL && iterator->next->content.ptr!=delimiter) |
278 |
|
iterator= iterator->next; |
279 |
|
|
280 |
|
temp= *stack_head; |
281 |
|
*stack_head= iterator->next; |
282 |
|
iterator->next= NULL; |
283 |
|
|
284 |
|
if(*stack_head!=NULL && (*stack_head)->content.ptr==delimiter) |
285 |
|
toss(stack_head); |
286 |
|
|
287 |
|
pack= malloc(sizeof(stackitem)); |
288 |
|
pack->type= list; |
289 |
|
pack->content.ptr= temp; |
290 |
|
|
291 |
|
push(stack_head, pack); |
292 |
} |
} |
293 |
|
|
294 |
extern void nl() |
extern void expand(stackitem** stack_head) |
295 |
{ |
{ |
296 |
printf("\n"); |
stackitem *temp, *new_head; |
297 |
|
|
298 |
|
if((*stack_head)==NULL || (*stack_head)->type!=list) |
299 |
|
return; |
300 |
|
|
301 |
|
new_head= temp= (*stack_head)->content.ptr; |
302 |
|
toss(stack_head); |
303 |
|
|
304 |
|
while(temp->next!=NULL) |
305 |
|
temp= temp->next; |
306 |
|
|
307 |
|
temp->next= *stack_head; |
308 |
|
*stack_head= new_head; |
309 |
} |
} |
310 |
|
|
311 |
extern void quit() |
extern void quit() |