118 |
stackitem *nitem= malloc(sizeof(stackitem)); |
stackitem *nitem= malloc(sizeof(stackitem)); |
119 |
|
|
120 |
nval->content.ptr= NULL; |
nval->content.ptr= NULL; |
|
protect(env, nval); |
|
|
|
|
|
gc_init(env); |
|
121 |
|
|
122 |
nitem->item= nval; |
nitem->item= nval; |
123 |
nitem->next= env->gc_ref; |
nitem->next= env->gc_ref; |
124 |
env->gc_ref= nitem; |
env->gc_ref= nitem; |
125 |
|
|
126 |
env->gc_count++; |
env->gc_count++; |
127 |
|
|
128 |
|
protect(env, nval); |
129 |
|
gc_init(env); |
130 |
unprotect(env); |
unprotect(env); |
131 |
|
|
132 |
return nval; |
return nval; |
151 |
} |
} |
152 |
|
|
153 |
extern void gc_init(environment *env) { |
extern void gc_init(environment *env) { |
154 |
stackitem *new_head= NULL, *titem, *iterator= env->gc_ref; |
stackitem *new_head= NULL, *titem, *iterator; |
155 |
symbol *tsymb; |
symbol *tsymb; |
156 |
int i; |
int i; |
157 |
|
|
158 |
if(env->gc_count < env->gc_limit) |
if(env->gc_count < env->gc_limit) |
159 |
return; |
return; |
160 |
|
|
161 |
|
/* Garb by default */ |
162 |
|
iterator= env->gc_ref; |
163 |
while(iterator!=NULL) { |
while(iterator!=NULL) { |
164 |
iterator->item->gc_garb= 1; |
iterator->item->gc_garb= 1; |
165 |
iterator= iterator->next; |
iterator= iterator->next; |
166 |
} |
} |
167 |
|
|
168 |
/* Mark */ |
/* Mark protected values */ |
169 |
iterator= env->gc_protect; |
iterator= env->gc_protect; |
170 |
while(iterator!=NULL) { |
while(iterator!=NULL) { |
171 |
gc_mark(iterator->item); |
gc_mark(iterator->item); |
172 |
iterator= iterator->next; |
iterator= iterator->next; |
173 |
} |
} |
174 |
|
|
175 |
|
/* Mark values in stack */ |
176 |
iterator= env->head; |
iterator= env->head; |
177 |
while(iterator!=NULL) { |
while(iterator!=NULL) { |
178 |
gc_mark(iterator->item); |
gc_mark(iterator->item); |
179 |
iterator= iterator->next; |
iterator= iterator->next; |
180 |
} |
} |
181 |
|
|
182 |
|
/* Mark values in hashtable */ |
183 |
for(i= 0; i<HASHTBLSIZE; i++) { |
for(i= 0; i<HASHTBLSIZE; i++) { |
184 |
tsymb= env->symbols[i]; |
tsymb= env->symbols[i]; |
185 |
while(tsymb!=NULL) { |
while(tsymb!=NULL) { |
194 |
while(env->gc_ref!=NULL) { |
while(env->gc_ref!=NULL) { |
195 |
|
|
196 |
if(env->gc_ref->item->gc_garb) { |
if(env->gc_ref->item->gc_garb) { |
197 |
switch(env->gc_ref->item->type) { |
|
198 |
|
/* Remove content */ |
199 |
|
switch(env->gc_ref->item->type) { |
200 |
case string: |
case string: |
201 |
free(env->gc_ref->item->content.ptr); |
free(env->gc_ref->item->content.ptr); |
202 |
break; |
break; |
|
case integer: |
|
|
break; |
|
203 |
case list: |
case list: |
204 |
while(env->gc_ref->item->content.ptr!=NULL) { |
while(env->gc_ref->item->content.ptr!=NULL) { |
205 |
titem= env->gc_ref->item->content.ptr; |
titem= env->gc_ref->item->content.ptr; |
210 |
default: |
default: |
211 |
break; |
break; |
212 |
} |
} |
213 |
free(env->gc_ref->item); |
free(env->gc_ref->item); /* Remove from gc_ref */ |
214 |
titem= env->gc_ref->next; |
titem= env->gc_ref->next; |
215 |
free(env->gc_ref); |
free(env->gc_ref); /* Remove value */ |
216 |
env->gc_ref= titem; |
env->gc_ref= titem; |
217 |
} else { |
} else { /* Save */ |
218 |
titem= env->gc_ref->next; |
titem= env->gc_ref->next; |
219 |
env->gc_ref->next= new_head; |
env->gc_ref->next= new_head; |
220 |
new_head= env->gc_ref; |
new_head= env->gc_ref; |
256 |
{ |
{ |
257 |
value *new_value= new_val(env); |
value *new_value= new_val(env); |
258 |
|
|
259 |
new_value->content.val= in_val; |
new_value->content.i= in_val; |
260 |
new_value->type= integer; |
new_value->type= integer; |
261 |
|
|
262 |
push_val(env, new_value); |
push_val(env, new_value); |
263 |
} |
} |
264 |
|
|
265 |
|
void push_float(environment *env, float in_val) |
266 |
|
{ |
267 |
|
value *new_value= new_val(env); |
268 |
|
|
269 |
|
new_value->content.f= in_val; |
270 |
|
new_value->type= tfloat; |
271 |
|
|
272 |
|
push_val(env, new_value); |
273 |
|
} |
274 |
|
|
275 |
/* Copy a string onto the stack. */ |
/* Copy a string onto the stack. */ |
276 |
void push_cstring(environment *env, const char *in_string) |
void push_cstring(environment *env, const char *in_string) |
277 |
{ |
{ |
342 |
char *mangled; /* Mangled function name */ |
char *mangled; /* Mangled function name */ |
343 |
|
|
344 |
new_value= new_val(env); |
new_value= new_val(env); |
345 |
|
protect(env, new_value); |
346 |
|
new_fvalue= new_val(env); |
347 |
|
protect(env, new_fvalue); |
348 |
|
|
349 |
/* The new value is a symbol */ |
/* The new value is a symbol */ |
350 |
new_value->type= symb; |
new_value->type= symb; |
379 |
dlerr= dlerror(); |
dlerr= dlerror(); |
380 |
} |
} |
381 |
if(dlerr==NULL) { /* If a function was found */ |
if(dlerr==NULL) { /* If a function was found */ |
|
new_fvalue= new_val(env); /* Create a new value */ |
|
382 |
new_fvalue->type= func; /* The new value is a function pointer */ |
new_fvalue->type= func; /* The new value is a function pointer */ |
383 |
new_fvalue->content.ptr= funcptr; /* Store function pointer */ |
new_fvalue->content.ptr= funcptr; /* Store function pointer */ |
384 |
(*new_symbol)->val= new_fvalue; /* Bind the symbol to the new |
(*new_symbol)->val= new_fvalue; /* Bind the symbol to the new |
386 |
} |
} |
387 |
} |
} |
388 |
push_val(env, new_value); |
push_val(env, new_value); |
389 |
|
unprotect(env); unprotect(env); |
390 |
} |
} |
391 |
|
|
392 |
/* Print newline. */ |
/* Print newline. */ |
410 |
case integer: |
case integer: |
411 |
push_sym(env, "integer"); |
push_sym(env, "integer"); |
412 |
break; |
break; |
413 |
|
case tfloat: |
414 |
|
push_sym(env, "float"); |
415 |
|
break; |
416 |
case string: |
case string: |
417 |
push_sym(env, "string"); |
push_sym(env, "string"); |
418 |
break; |
break; |
433 |
{ |
{ |
434 |
switch(stack_head->item->type) { |
switch(stack_head->item->type) { |
435 |
case integer: |
case integer: |
436 |
printf("%d", stack_head->item->content.val); |
printf("%d", stack_head->item->content.i); |
437 |
|
break; |
438 |
|
case tfloat: |
439 |
|
printf("%f", stack_head->item->content.f); |
440 |
break; |
break; |
441 |
case string: |
case string: |
442 |
if(noquote) |
if(noquote) |
620 |
case list: |
case list: |
621 |
temp_val= env->head->item; |
temp_val= env->head->item; |
622 |
protect(env, temp_val); |
protect(env, temp_val); |
623 |
toss(env); |
|
624 |
if(env->err) return; |
toss(env); if(env->err) return; |
625 |
iterator= (stackitem*)temp_val->content.ptr; |
iterator= (stackitem*)temp_val->content.ptr; |
|
unprotect(env); |
|
626 |
|
|
627 |
while(iterator!=NULL) { |
while(iterator!=NULL) { |
628 |
push_val(env, iterator->item); |
push_val(env, iterator->item); |
640 |
} |
} |
641 |
iterator= iterator->next; |
iterator= iterator->next; |
642 |
} |
} |
643 |
|
unprotect(env); |
644 |
return; |
return; |
645 |
|
|
646 |
default: |
default: |
682 |
value *pack; |
value *pack; |
683 |
|
|
684 |
iterator= env->head; |
iterator= env->head; |
685 |
|
pack= new_val(env); |
686 |
|
protect(env, pack); |
687 |
|
|
688 |
if(iterator==NULL |
if(iterator==NULL |
689 |
|| (iterator->item->type==symb |
|| (iterator->item->type==symb |
701 |
temp= env->head; |
temp= env->head; |
702 |
env->head= iterator->next; |
env->head= iterator->next; |
703 |
iterator->next= NULL; |
iterator->next= NULL; |
704 |
|
|
705 |
|
pack->type= list; |
706 |
|
pack->content.ptr= temp; |
707 |
|
|
708 |
if(env->head!=NULL) |
if(env->head!=NULL) |
709 |
toss(env); |
toss(env); |
710 |
} |
} |
711 |
|
|
712 |
/* Push list */ |
/* Push list */ |
|
pack= new_val(env); |
|
|
pack->type= list; |
|
|
pack->content.ptr= temp; |
|
713 |
|
|
714 |
push_val(env, pack); |
push_val(env, pack); |
715 |
rev(env); |
rev(env); |
716 |
|
|
717 |
|
unprotect(env); |
718 |
} |
} |
719 |
|
|
720 |
/* Relocate elements of the list on the stack. */ |
/* Relocate elements of the list on the stack. */ |
792 |
return; |
return; |
793 |
} |
} |
794 |
|
|
795 |
val= env->head->item->content.val; |
val= env->head->item->content.i; |
796 |
toss(env); |
toss(env); |
797 |
push_int(env, !val); |
push_int(env, !val); |
798 |
} |
} |
994 |
/* "+" */ |
/* "+" */ |
995 |
extern void sx_2b(environment *env) { |
extern void sx_2b(environment *env) { |
996 |
int a, b; |
int a, b; |
997 |
|
float fa, fb; |
998 |
size_t len; |
size_t len; |
999 |
char* new_string; |
char* new_string; |
1000 |
value *a_val, *b_val; |
value *a_val, *b_val; |
1019 |
push_cstring(env, new_string); |
push_cstring(env, new_string); |
1020 |
unprotect(env); unprotect(env); |
unprotect(env); unprotect(env); |
1021 |
free(new_string); |
free(new_string); |
1022 |
|
|
1023 |
return; |
return; |
1024 |
} |
} |
1025 |
|
|
1026 |
if(env->head->item->type!=integer |
if(env->head->item->type==integer |
1027 |
|| env->head->next->item->type!=integer) { |
&& env->head->next->item->type==integer) { |
1028 |
printerr("Bad Argument Type"); |
a=env->head->item->content.i; |
1029 |
env->err=2; |
toss(env); if(env->err) return; |
1030 |
|
b=env->head->item->content.i; |
1031 |
|
toss(env); if(env->err) return; |
1032 |
|
push_int(env, b+a); |
1033 |
|
|
1034 |
return; |
return; |
1035 |
} |
} |
1036 |
a= env->head->item->content.val; |
|
1037 |
toss(env); if(env->err) return; |
if(env->head->item->type==tfloat |
1038 |
|
&& env->head->next->item->type==tfloat) { |
1039 |
b= env->head->item->content.val; |
fa= env->head->item->content.f; |
1040 |
toss(env); if(env->err) return; |
toss(env); if(env->err) return; |
1041 |
push_int(env, a+b); |
fb= env->head->item->content.f; |
1042 |
|
toss(env); if(env->err) return; |
1043 |
|
push_float(env, fb+fa); |
1044 |
|
|
1045 |
|
return; |
1046 |
|
} |
1047 |
|
|
1048 |
|
if(env->head->item->type==tfloat |
1049 |
|
&& env->head->next->item->type==integer) { |
1050 |
|
fa= env->head->item->content.f; |
1051 |
|
toss(env); if(env->err) return; |
1052 |
|
b= env->head->item->content.i; |
1053 |
|
toss(env); if(env->err) return; |
1054 |
|
push_float(env, b+fa); |
1055 |
|
|
1056 |
|
return; |
1057 |
|
} |
1058 |
|
|
1059 |
|
if(env->head->item->type==integer |
1060 |
|
&& env->head->next->item->type==tfloat) { |
1061 |
|
a= env->head->item->content.i; |
1062 |
|
toss(env); if(env->err) return; |
1063 |
|
fb= env->head->item->content.f; |
1064 |
|
toss(env); if(env->err) return; |
1065 |
|
push_float(env, fb+a); |
1066 |
|
|
1067 |
|
return; |
1068 |
|
} |
1069 |
|
|
1070 |
|
printerr("Bad Argument Type"); |
1071 |
|
env->err=2; |
1072 |
} |
} |
1073 |
|
|
1074 |
/* "-" */ |
/* "-" */ |
1075 |
extern void sx_2d(environment *env) { |
extern void sx_2d(environment *env) { |
1076 |
int a, b; |
int a, b; |
1077 |
|
float fa, fb; |
1078 |
|
|
1079 |
if((env->head)==NULL || env->head->next==NULL) { |
if((env->head)==NULL || env->head->next==NULL) { |
1080 |
printerr("Too Few Arguments"); |
printerr("Too Few Arguments"); |
1082 |
return; |
return; |
1083 |
} |
} |
1084 |
|
|
1085 |
if(env->head->item->type!=integer |
if(env->head->item->type==integer |
1086 |
|| env->head->next->item->type!=integer) { |
&& env->head->next->item->type==integer) { |
1087 |
printerr("Bad Argument Type"); |
a=env->head->item->content.i; |
1088 |
env->err=2; |
toss(env); if(env->err) return; |
1089 |
|
b=env->head->item->content.i; |
1090 |
|
toss(env); if(env->err) return; |
1091 |
|
push_int(env, b-a); |
1092 |
|
|
1093 |
return; |
return; |
1094 |
} |
} |
1095 |
|
|
1096 |
a=env->head->item->content.val; |
if(env->head->item->type==tfloat |
1097 |
toss(env); if(env->err) return; |
&& env->head->next->item->type==tfloat) { |
1098 |
b=env->head->item->content.val; |
fa= env->head->item->content.f; |
1099 |
toss(env); if(env->err) return; |
toss(env); if(env->err) return; |
1100 |
push_int(env, b-a); |
fb= env->head->item->content.f; |
1101 |
|
toss(env); if(env->err) return; |
1102 |
|
push_float(env, fb-fa); |
1103 |
|
|
1104 |
|
return; |
1105 |
|
} |
1106 |
|
|
1107 |
|
if(env->head->item->type==tfloat |
1108 |
|
&& env->head->next->item->type==integer) { |
1109 |
|
fa= env->head->item->content.f; |
1110 |
|
toss(env); if(env->err) return; |
1111 |
|
b= env->head->item->content.i; |
1112 |
|
toss(env); if(env->err) return; |
1113 |
|
push_float(env, b-fa); |
1114 |
|
|
1115 |
|
return; |
1116 |
|
} |
1117 |
|
|
1118 |
|
if(env->head->item->type==integer |
1119 |
|
&& env->head->next->item->type==tfloat) { |
1120 |
|
a= env->head->item->content.i; |
1121 |
|
toss(env); if(env->err) return; |
1122 |
|
fb= env->head->item->content.f; |
1123 |
|
toss(env); if(env->err) return; |
1124 |
|
push_float(env, fb-a); |
1125 |
|
|
1126 |
|
return; |
1127 |
|
} |
1128 |
|
|
1129 |
|
printerr("Bad Argument Type"); |
1130 |
|
env->err=2; |
1131 |
} |
} |
1132 |
|
|
1133 |
/* ">" */ |
/* ">" */ |
1134 |
extern void sx_3e(environment *env) { |
extern void sx_3e(environment *env) { |
1135 |
int a, b; |
int a, b; |
1136 |
|
float fa, fb; |
1137 |
|
|
1138 |
if((env->head)==NULL || env->head->next==NULL) { |
if((env->head)==NULL || env->head->next==NULL) { |
1139 |
printerr("Too Few Arguments"); |
printerr("Too Few Arguments"); |
1141 |
return; |
return; |
1142 |
} |
} |
1143 |
|
|
1144 |
if(env->head->item->type!=integer |
if(env->head->item->type==integer |
1145 |
|| env->head->next->item->type!=integer) { |
&& env->head->next->item->type==integer) { |
1146 |
printerr("Bad Argument Type"); |
a=env->head->item->content.i; |
1147 |
env->err=2; |
toss(env); if(env->err) return; |
1148 |
|
b=env->head->item->content.i; |
1149 |
|
toss(env); if(env->err) return; |
1150 |
|
push_int(env, b>a); |
1151 |
|
|
1152 |
return; |
return; |
1153 |
} |
} |
1154 |
|
|
1155 |
a=env->head->item->content.val; |
if(env->head->item->type==tfloat |
1156 |
toss(env); if(env->err) return; |
&& env->head->next->item->type==tfloat) { |
1157 |
b=env->head->item->content.val; |
fa= env->head->item->content.f; |
1158 |
toss(env); if(env->err) return; |
toss(env); if(env->err) return; |
1159 |
push_int(env, b>a); |
fb= env->head->item->content.f; |
1160 |
|
toss(env); if(env->err) return; |
1161 |
|
push_int(env, fb>fa); |
1162 |
|
|
1163 |
|
return; |
1164 |
|
} |
1165 |
|
|
1166 |
|
if(env->head->item->type==tfloat |
1167 |
|
&& env->head->next->item->type==integer) { |
1168 |
|
fa= env->head->item->content.f; |
1169 |
|
toss(env); if(env->err) return; |
1170 |
|
b= env->head->item->content.i; |
1171 |
|
toss(env); if(env->err) return; |
1172 |
|
push_int(env, b>fa); |
1173 |
|
|
1174 |
|
return; |
1175 |
|
} |
1176 |
|
|
1177 |
|
if(env->head->item->type==integer |
1178 |
|
&& env->head->next->item->type==tfloat) { |
1179 |
|
a= env->head->item->content.i; |
1180 |
|
toss(env); if(env->err) return; |
1181 |
|
fb= env->head->item->content.f; |
1182 |
|
toss(env); if(env->err) return; |
1183 |
|
push_int(env, fb>a); |
1184 |
|
|
1185 |
|
return; |
1186 |
|
} |
1187 |
|
|
1188 |
|
printerr("Bad Argument Type"); |
1189 |
|
env->err=2; |
1190 |
|
} |
1191 |
|
|
1192 |
|
/* "<" */ |
1193 |
|
extern void sx_3c(environment *env) { |
1194 |
|
swap(env); if(env->err) return; |
1195 |
|
sx_3e(env); |
1196 |
|
} |
1197 |
|
|
1198 |
|
/* "<=" */ |
1199 |
|
extern void sx_3c3d(environment *env) { |
1200 |
|
sx_3e(env); if(env->err) return; |
1201 |
|
not(env); |
1202 |
|
} |
1203 |
|
|
1204 |
|
/* ">=" */ |
1205 |
|
extern void sx_3e3d(environment *env) { |
1206 |
|
sx_3c(env); if(env->err) return; |
1207 |
|
not(env); |
1208 |
} |
} |
1209 |
|
|
1210 |
/* Return copy of a value */ |
/* Return copy of a value */ |
1211 |
value *copy_val(environment *env, value *old_value){ |
value *copy_val(environment *env, value *old_value){ |
1212 |
stackitem *old_item, *new_item, *prev_item; |
stackitem *old_item, *new_item, *prev_item; |
1213 |
|
value *new_value; |
|
value *new_value= new_val(env); |
|
1214 |
|
|
1215 |
protect(env, old_value); |
protect(env, old_value); |
1216 |
|
new_value= new_val(env); |
1217 |
|
protect(env, new_value); |
1218 |
new_value->type= old_value->type; |
new_value->type= old_value->type; |
1219 |
|
|
1220 |
switch(old_value->type){ |
switch(old_value->type){ |
1221 |
|
case tfloat: |
1222 |
case integer: |
case integer: |
1223 |
new_value->content.val= old_value->content.val; |
case func: |
1224 |
|
case symb: |
1225 |
|
new_value->content= old_value->content; |
1226 |
break; |
break; |
1227 |
case string: |
case string: |
1228 |
(char *)(new_value->content.ptr)= |
(char *)(new_value->content.ptr)= |
1229 |
strdup((char *)(old_value->content.ptr)); |
strdup((char *)(old_value->content.ptr)); |
1230 |
break; |
break; |
|
case func: |
|
|
case symb: |
|
|
new_value->content.ptr= old_value->content.ptr; |
|
|
break; |
|
1231 |
case list: |
case list: |
1232 |
new_value->content.ptr= NULL; |
new_value->content.ptr= NULL; |
1233 |
|
|
1249 |
break; |
break; |
1250 |
} |
} |
1251 |
|
|
1252 |
unprotect(env); |
unprotect(env); unprotect(env); |
1253 |
|
|
1254 |
return new_value; |
return new_value; |
1255 |
} |
} |
1284 |
swap(env); |
swap(env); |
1285 |
if(env->err) return; |
if(env->err) return; |
1286 |
|
|
1287 |
truth=env->head->item->content.val; |
truth=env->head->item->content.i; |
1288 |
|
|
1289 |
toss(env); |
toss(env); |
1290 |
if(env->err) return; |
if(env->err) return; |
1316 |
rot(env); |
rot(env); |
1317 |
if(env->err) return; |
if(env->err) return; |
1318 |
|
|
1319 |
truth=env->head->item->content.val; |
truth=env->head->item->content.i; |
1320 |
|
|
1321 |
toss(env); |
toss(env); |
1322 |
if(env->err) return; |
if(env->err) return; |
1361 |
return; |
return; |
1362 |
} |
} |
1363 |
|
|
1364 |
truth= env->head->item->content.val; |
truth= env->head->item->content.i; |
1365 |
toss(env); if(env->err) return; |
toss(env); if(env->err) return; |
1366 |
|
|
1367 |
if(truth) { |
if(truth) { |
1400 |
protect(env, loop); |
protect(env, loop); |
1401 |
toss(env); if(env->err) return; |
toss(env); if(env->err) return; |
1402 |
|
|
1403 |
foo2= env->head->item->content.val; |
foo2= env->head->item->content.i; |
1404 |
toss(env); if(env->err) return; |
toss(env); if(env->err) return; |
1405 |
|
|
1406 |
foo1= env->head->item->content.val; |
foo1= env->head->item->content.i; |
1407 |
toss(env); if(env->err) return; |
toss(env); if(env->err) return; |
1408 |
|
|
1409 |
if(foo1<=foo2) { |
if(foo1<=foo2) { |
1480 |
return; |
return; |
1481 |
} |
} |
1482 |
|
|
1483 |
ending= env->head->item->content.val; |
ending= env->head->item->content.i; |
1484 |
toss(env); if(env->err) return; |
toss(env); if(env->err) return; |
1485 |
start= env->head->item->content.val; |
start= env->head->item->content.i; |
1486 |
toss(env); if(env->err) return; |
toss(env); if(env->err) return; |
1487 |
|
|
1488 |
temp_head= env->head; |
temp_head= env->head; |
1497 |
} |
} |
1498 |
|
|
1499 |
temp_val= new_val(env); |
temp_val= new_val(env); |
1500 |
|
protect(env, temp_val); |
1501 |
|
|
1502 |
temp_val->content.ptr= env->head; |
temp_val->content.ptr= env->head; |
1503 |
temp_val->type= list; |
temp_val->type= list; |
1504 |
env->head= temp_head; |
env->head= temp_head; |
1505 |
push_val(env, temp_val); |
push_val(env, temp_val); |
1506 |
|
|
1507 |
|
unprotect(env); |
1508 |
} |
} |
1509 |
|
|
1510 |
/* Read a string */ |
/* Read a string */ |
1522 |
const char symbform[]= "%[a-zA-Z0-9!$%*+./:<=>?@^_~-]%n"; |
const char symbform[]= "%[a-zA-Z0-9!$%*+./:<=>?@^_~-]%n"; |
1523 |
const char strform[]= "\"%[^\"]\"%n"; |
const char strform[]= "\"%[^\"]\"%n"; |
1524 |
const char intform[]= "%i%n"; |
const char intform[]= "%i%n"; |
1525 |
|
const char fltform[]= "%f%n"; |
1526 |
const char blankform[]= "%*[ \t]%n"; |
const char blankform[]= "%*[ \t]%n"; |
1527 |
const char ebrackform[]= "]%n"; |
const char ebrackform[]= "]%n"; |
1528 |
const char semicform[]= ";%n"; |
const char semicform[]= ";%n"; |
1529 |
const char bbrackform[]= "[%n"; |
const char bbrackform[]= "[%n"; |
1530 |
|
|
1531 |
int itemp, readlength= -1; |
int itemp, readlength= -1; |
1532 |
|
int count= -1; |
1533 |
|
float ftemp; |
1534 |
static int depth= 0; |
static int depth= 0; |
1535 |
char *match; |
char *match, *ctemp; |
1536 |
size_t inlength; |
size_t inlength; |
1537 |
|
|
1538 |
if(env->in_string==NULL) { |
if(env->in_string==NULL) { |
1555 |
inlength= strlen(env->in_string)+1; |
inlength= strlen(env->in_string)+1; |
1556 |
match= malloc(inlength); |
match= malloc(inlength); |
1557 |
|
|
1558 |
if(sscanf(env->in_string, blankform, &readlength)!=EOF |
if(sscanf(env->in_string, blankform, &readlength) != EOF |
1559 |
&& readlength != -1) { |
&& readlength != -1) { |
1560 |
; |
; |
1561 |
} else if(sscanf(env->in_string, intform, &itemp, &readlength) != EOF |
} else if(sscanf(env->in_string, fltform, &ftemp, &readlength) != EOF |
1562 |
&& readlength != -1) { |
&& readlength != -1) { |
1563 |
push_int(env, itemp); |
if(sscanf(env->in_string, intform, &itemp, &count) != EOF |
1564 |
|
&& count==readlength) { |
1565 |
|
push_int(env, itemp); |
1566 |
|
} else { |
1567 |
|
push_float(env, ftemp); |
1568 |
|
} |
1569 |
} else if(sscanf(env->in_string, strform, match, &readlength) != EOF |
} else if(sscanf(env->in_string, strform, match, &readlength) != EOF |
1570 |
&& readlength != -1) { |
&& readlength != -1) { |
1571 |
push_cstring(env, match); |
push_cstring(env, match); |
1587 |
free(env->free_string); |
free(env->free_string); |
1588 |
env->in_string = env->free_string = NULL; |
env->in_string = env->free_string = NULL; |
1589 |
} |
} |
1590 |
if ( env->in_string != NULL) { |
if (env->in_string != NULL) { |
1591 |
env->in_string += readlength; |
env->in_string += readlength; |
1592 |
} |
} |
1593 |
|
|
1614 |
return; |
return; |
1615 |
} |
} |
1616 |
|
|
1617 |
dur=env->head->item->content.val; |
dur=env->head->item->content.i; |
1618 |
toss(env); |
toss(env); |
1619 |
freq=env->head->item->content.val; |
freq=env->head->item->content.i; |
1620 |
toss(env); |
toss(env); |
1621 |
|
|
1622 |
period=1193180/freq; /* convert freq from Hz to period |
period=1193180/freq; /* convert freq from Hz to period |
1657 |
return; |
return; |
1658 |
} |
} |
1659 |
|
|
1660 |
dur=env->head->item->content.val; |
dur=env->head->item->content.i; |
1661 |
toss(env); |
toss(env); |
1662 |
|
|
1663 |
usleep(dur); |
usleep(dur); |
1945 |
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE\n\ |
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE\n\ |
1946 |
POSSIBILITY OF SUCH DAMAGES.\n"); |
POSSIBILITY OF SUCH DAMAGES.\n"); |
1947 |
} |
} |
1948 |
|
|
1949 |
|
/* "*" */ |
1950 |
|
extern void sx_2a(environment *env) |
1951 |
|
{ |
1952 |
|
int a, b; |
1953 |
|
float fa, fb; |
1954 |
|
|
1955 |
|
if((env->head)==NULL || env->head->next==NULL) { |
1956 |
|
printerr("Too Few Arguments"); |
1957 |
|
env->err=1; |
1958 |
|
return; |
1959 |
|
} |
1960 |
|
|
1961 |
|
if(env->head->item->type==integer |
1962 |
|
&& env->head->next->item->type==integer) { |
1963 |
|
a=env->head->item->content.i; |
1964 |
|
toss(env); if(env->err) return; |
1965 |
|
b=env->head->item->content.i; |
1966 |
|
toss(env); if(env->err) return; |
1967 |
|
push_int(env, b*a); |
1968 |
|
|
1969 |
|
return; |
1970 |
|
} |
1971 |
|
|
1972 |
|
if(env->head->item->type==tfloat |
1973 |
|
&& env->head->next->item->type==tfloat) { |
1974 |
|
fa= env->head->item->content.f; |
1975 |
|
toss(env); if(env->err) return; |
1976 |
|
fb= env->head->item->content.f; |
1977 |
|
toss(env); if(env->err) return; |
1978 |
|
push_float(env, fb*fa); |
1979 |
|
|
1980 |
|
return; |
1981 |
|
} |
1982 |
|
|
1983 |
|
if(env->head->item->type==tfloat |
1984 |
|
&& env->head->next->item->type==integer) { |
1985 |
|
fa= env->head->item->content.f; |
1986 |
|
toss(env); if(env->err) return; |
1987 |
|
b= env->head->item->content.i; |
1988 |
|
toss(env); if(env->err) return; |
1989 |
|
push_float(env, b*fa); |
1990 |
|
|
1991 |
|
return; |
1992 |
|
} |
1993 |
|
|
1994 |
|
if(env->head->item->type==integer |
1995 |
|
&& env->head->next->item->type==tfloat) { |
1996 |
|
a= env->head->item->content.i; |
1997 |
|
toss(env); if(env->err) return; |
1998 |
|
fb= env->head->item->content.f; |
1999 |
|
toss(env); if(env->err) return; |
2000 |
|
push_float(env, fb*a); |
2001 |
|
|
2002 |
|
return; |
2003 |
|
} |
2004 |
|
|
2005 |
|
printerr("Bad Argument Type"); |
2006 |
|
env->err=2; |
2007 |
|
} |
2008 |
|
|
2009 |
|
/* "/" */ |
2010 |
|
extern void sx_2f(environment *env) |
2011 |
|
{ |
2012 |
|
int a, b; |
2013 |
|
float fa, fb; |
2014 |
|
|
2015 |
|
if((env->head)==NULL || env->head->next==NULL) { |
2016 |
|
printerr("Too Few Arguments"); |
2017 |
|
env->err=1; |
2018 |
|
return; |
2019 |
|
} |
2020 |
|
|
2021 |
|
if(env->head->item->type==integer |
2022 |
|
&& env->head->next->item->type==integer) { |
2023 |
|
a=env->head->item->content.i; |
2024 |
|
toss(env); if(env->err) return; |
2025 |
|
b=env->head->item->content.i; |
2026 |
|
toss(env); if(env->err) return; |
2027 |
|
push_float(env, b/a); |
2028 |
|
|
2029 |
|
return; |
2030 |
|
} |
2031 |
|
|
2032 |
|
if(env->head->item->type==tfloat |
2033 |
|
&& env->head->next->item->type==tfloat) { |
2034 |
|
fa= env->head->item->content.f; |
2035 |
|
toss(env); if(env->err) return; |
2036 |
|
fb= env->head->item->content.f; |
2037 |
|
toss(env); if(env->err) return; |
2038 |
|
push_float(env, fb/fa); |
2039 |
|
|
2040 |
|
return; |
2041 |
|
} |
2042 |
|
|
2043 |
|
if(env->head->item->type==tfloat |
2044 |
|
&& env->head->next->item->type==integer) { |
2045 |
|
fa= env->head->item->content.f; |
2046 |
|
toss(env); if(env->err) return; |
2047 |
|
b= env->head->item->content.i; |
2048 |
|
toss(env); if(env->err) return; |
2049 |
|
push_float(env, b/fa); |
2050 |
|
|
2051 |
|
return; |
2052 |
|
} |
2053 |
|
|
2054 |
|
if(env->head->item->type==integer |
2055 |
|
&& env->head->next->item->type==tfloat) { |
2056 |
|
a= env->head->item->content.i; |
2057 |
|
toss(env); if(env->err) return; |
2058 |
|
fb= env->head->item->content.f; |
2059 |
|
toss(env); if(env->err) return; |
2060 |
|
push_float(env, fb/a); |
2061 |
|
|
2062 |
|
return; |
2063 |
|
} |
2064 |
|
|
2065 |
|
printerr("Bad Argument Type"); |
2066 |
|
env->err=2; |
2067 |
|
} |
2068 |
|
|
2069 |
|
/* "mod" */ |
2070 |
|
extern void mod(environment *env) |
2071 |
|
{ |
2072 |
|
int a, b; |
2073 |
|
|
2074 |
|
if((env->head)==NULL || env->head->next==NULL) { |
2075 |
|
printerr("Too Few Arguments"); |
2076 |
|
env->err= 1; |
2077 |
|
return; |
2078 |
|
} |
2079 |
|
|
2080 |
|
if(env->head->item->type==integer |
2081 |
|
&& env->head->next->item->type==integer) { |
2082 |
|
a= env->head->item->content.i; |
2083 |
|
toss(env); if(env->err) return; |
2084 |
|
b= env->head->item->content.i; |
2085 |
|
toss(env); if(env->err) return; |
2086 |
|
push_int(env, b%a); |
2087 |
|
|
2088 |
|
return; |
2089 |
|
} |
2090 |
|
|
2091 |
|
printerr("Bad Argument Type"); |
2092 |
|
env->err=2; |
2093 |
|
} |
2094 |
|
|
2095 |
|
/* "div" */ |
2096 |
|
extern void sx_646976(environment *env) |
2097 |
|
{ |
2098 |
|
int a, b; |
2099 |
|
|
2100 |
|
if((env->head)==NULL || env->head->next==NULL) { |
2101 |
|
printerr("Too Few Arguments"); |
2102 |
|
env->err= 1; |
2103 |
|
return; |
2104 |
|
} |
2105 |
|
|
2106 |
|
if(env->head->item->type==integer |
2107 |
|
&& env->head->next->item->type==integer) { |
2108 |
|
a= env->head->item->content.i; |
2109 |
|
toss(env); if(env->err) return; |
2110 |
|
b= env->head->item->content.i; |
2111 |
|
toss(env); if(env->err) return; |
2112 |
|
push_int(env, (int)b/a); |
2113 |
|
|
2114 |
|
return; |
2115 |
|
} |
2116 |
|
|
2117 |
|
printerr("Bad Argument Type"); |
2118 |
|
env->err= 2; |
2119 |
|
} |