cb2256 | 1995-10-11 | Fredrik Hübinette (Hubbe) | | |
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | ||| This file a part of Pike, and is copyright by Fredrik Hubinette
||| Pike is distributed as GPL (General Public License)
|
cb2256 | 1995-10-11 | Fredrik Hübinette (Hubbe) | | ||| See the files COPYING and DISCLAIMER for more information.
\*/
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | #include "global.h"
|
c7e132 | 1998-10-28 | Henrik Grubbström (Grubba) | | RCSID("$Id: pike_types.c,v 1.47 1998/10/28 03:17:23 grubba Exp $");
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | #include <ctype.h>
#include "svalue.h"
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | #include "pike_types.h"
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | #include "stralloc.h"
#include "stuff.h"
#include "array.h"
#include "program.h"
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | #include "constants.h"
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | #include "object.h"
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | #include "multiset.h"
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | #include "mapping.h"
|
bb55f8 | 1997-03-16 | Fredrik Hübinette (Hubbe) | | #include "pike_macros.h"
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | #include "error.h"
|
b8cda2 | 1997-01-21 | Fredrik Hübinette (Hubbe) | | #include "las.h"
#include "language.h"
|
9aa6fa | 1997-05-19 | Fredrik Hübinette (Hubbe) | | #include "pike_memory.h"
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
|
1d5328 | 1996-11-25 | Fredrik Hübinette (Hubbe) | | int max_correct_args;
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | static void internal_parse_type(char **s);
|
b9e4ba | 1996-11-18 | Fredrik Hübinette (Hubbe) | | static int type_length(char *t);
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | |
|
9f6847 | 1997-03-08 | Fredrik Hübinette (Hubbe) | | #define TWOT(X,Y) (((X) << 8)+(Y))
#define EXTRACT_TWOT(X,Y) TWOT(EXTRACT_UCHAR(X), EXTRACT_UCHAR(Y))
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | |
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | * multiset works similarly to arrays.
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | * functions are _very_ special:
* they are coded like this:
* T_FUNCTION <arg type> <arg type> ... <arg type> T_MANY <arg type> <return type>
* note that the type after T_MANY can be T_VOID
* T_MIXED matches anything except T_VOID
* T_UNKNOWN only matches T_MIXED and T_UNKNOWN
|
6bc928 | 1998-04-10 | Fredrik Hübinette (Hubbe) | | * objects are coded thus:
* T_OBJECT <0/1> <program_id>
* ^
* 0 means 'inherits'
* 1 means 'is'
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | */
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | struct pike_string *string_type_string;
struct pike_string *int_type_string;
struct pike_string *float_type_string;
struct pike_string *function_type_string;
struct pike_string *object_type_string;
struct pike_string *program_type_string;
struct pike_string *array_type_string;
struct pike_string *multiset_type_string;
struct pike_string *mapping_type_string;
struct pike_string *mixed_type_string;
struct pike_string *void_type_string;
struct pike_string *any_type_string;
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
|
a946c7 | 1998-03-02 | Fredrik Hübinette (Hubbe) | | static struct pike_string *a_markers[10],*b_markers[10];
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | |
|
22ca07 | 1998-04-08 | Fredrik Hübinette (Hubbe) | | static void clear_markers(void)
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | {
unsigned int e;
|
a946c7 | 1998-03-02 | Fredrik Hübinette (Hubbe) | | for(e=0;e<NELEM(a_markers);e++)
{
if(a_markers[e])
{
free_string(a_markers[e]);
a_markers[e]=0;
}
if(b_markers[e])
{
free_string(b_markers[e]);
b_markers[e]=0;
}
}
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | }
|
b9e4ba | 1996-11-18 | Fredrik Hübinette (Hubbe) | | #ifdef DEBUG
static void CHECK_TYPE(struct pike_string *s)
{
if(debug_findstring(s) != s)
fatal("Type string not shared.\n");
if(type_length(s->str) != s->len)
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | {
stupid_describe_type(s->str,s->len);
|
6bc928 | 1998-04-10 | Fredrik Hübinette (Hubbe) | | fatal("Length of type is wrong. (should be %d, is %d)\n",type_length(s->str),s->len);
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | }
|
b9e4ba | 1996-11-18 | Fredrik Hübinette (Hubbe) | | }
#else
#define CHECK_TYPE(X)
#endif
|
be478c | 1997-08-30 | Henrik Grubbström (Grubba) | | void init_types(void)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
string_type_string=parse_type("string");
int_type_string=parse_type("int");
object_type_string=parse_type("object");
program_type_string=parse_type("program");
float_type_string=parse_type("float");
mixed_type_string=parse_type("mixed");
array_type_string=parse_type("array");
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | multiset_type_string=parse_type("multiset");
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | mapping_type_string=parse_type("mapping");
function_type_string=parse_type("function");
void_type_string=parse_type("void");
|
f6f02d | 1995-10-16 | Fredrik Hübinette (Hubbe) | | any_type_string=parse_type("void|mixed");
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
static int type_length(char *t)
{
char *q=t;
|
134717 | 1998-04-23 | Fredrik Hübinette (Hubbe) | | one_more_type:
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | switch(EXTRACT_UCHAR(t++))
{
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | default:
fatal("error in type string.\n");
break;
case T_ASSIGN:
t++;
|
134717 | 1998-04-23 | Fredrik Hübinette (Hubbe) | | goto one_more_type;
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | |
case T_FUNCTION:
while(EXTRACT_UCHAR(t)!=T_MANY) t+=type_length(t);
t++;
case T_MAPPING:
case T_OR:
case T_AND:
t+=type_length(t);
case T_ARRAY:
case T_MULTISET:
case T_NOT:
|
134717 | 1998-04-23 | Fredrik Hübinette (Hubbe) | | goto one_more_type;
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | |
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case T_INT:
case T_FLOAT:
case T_STRING:
case T_PROGRAM:
case T_MIXED:
case T_VOID:
case T_UNKNOWN:
break;
case T_OBJECT:
|
6bc928 | 1998-04-10 | Fredrik Hübinette (Hubbe) | | t++;
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | t+=sizeof(INT32);
break;
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
return t-q;
}
|
726071 | 1996-06-21 | Fredrik Hübinette (Hubbe) | |
|
134717 | 1998-04-23 | Fredrik Hübinette (Hubbe) | | unsigned char type_stack[PIKE_TYPE_STACK_SIZE];
unsigned char *type_stackp=type_stack;
unsigned char *pike_type_mark_stack[PIKE_TYPE_STACK_SIZE/4];
unsigned char **pike_type_mark_stackp=pike_type_mark_stack;
|
726071 | 1996-06-21 | Fredrik Hübinette (Hubbe) | |
|
be478c | 1997-08-30 | Henrik Grubbström (Grubba) | | INT32 pop_stack_mark(void)
|
726071 | 1996-06-21 | Fredrik Hübinette (Hubbe) | | {
|
134717 | 1998-04-23 | Fredrik Hübinette (Hubbe) | | pike_type_mark_stackp--;
if(pike_type_mark_stackp<pike_type_mark_stack)
|
726071 | 1996-06-21 | Fredrik Hübinette (Hubbe) | | fatal("Type mark stack underflow\n");
|
134717 | 1998-04-23 | Fredrik Hübinette (Hubbe) | | return type_stackp - *pike_type_mark_stackp;
|
726071 | 1996-06-21 | Fredrik Hübinette (Hubbe) | | }
|
be478c | 1997-08-30 | Henrik Grubbström (Grubba) | | void pop_type_stack(void)
|
726071 | 1996-06-21 | Fredrik Hübinette (Hubbe) | | {
type_stackp--;
if(type_stackp<type_stack)
fatal("Type stack underflow\n");
}
|
be478c | 1997-08-30 | Henrik Grubbström (Grubba) | | void type_stack_pop_to_mark(void)
|
726071 | 1996-06-21 | Fredrik Hübinette (Hubbe) | | {
|
36feac | 1997-03-06 | Fredrik Hübinette (Hubbe) | | type_stackp-=pop_stack_mark();
#ifdef DEBUG
if(type_stackp<type_stack)
fatal("Type stack underflow\n");
#endif
|
726071 | 1996-06-21 | Fredrik Hübinette (Hubbe) | | }
|
be478c | 1997-08-30 | Henrik Grubbström (Grubba) | | void type_stack_reverse(void)
|
726071 | 1996-06-21 | Fredrik Hübinette (Hubbe) | | {
|
36feac | 1997-03-06 | Fredrik Hübinette (Hubbe) | | INT32 a;
a=pop_stack_mark();
|
5425bb | 1997-05-30 | Henrik Grubbström (Grubba) | | reverse((char *)(type_stackp-a),a,1);
|
726071 | 1996-06-21 | Fredrik Hübinette (Hubbe) | | }
|
d2c608 | 1996-11-07 | Fredrik Hübinette (Hubbe) | | void push_type_int(unsigned INT32 i)
{
|
36feac | 1997-03-06 | Fredrik Hübinette (Hubbe) | | int e;
for(e=sizeof(i)-1;e>=0;e--)
push_type(((unsigned char *)&i)[e]);
|
d2c608 | 1996-11-07 | Fredrik Hübinette (Hubbe) | | }
|
726071 | 1996-06-21 | Fredrik Hübinette (Hubbe) | | void push_unfinished_type(char *s)
{
int e;
e=type_length(s);
for(e--;e>=0;e--) push_type(s[e]);
}
|
a946c7 | 1998-03-02 | Fredrik Hübinette (Hubbe) | | static void push_unfinished_type_with_markers(char *s, struct pike_string **am)
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | {
|
2a6d26 | 1998-03-25 | Fredrik Hübinette (Hubbe) | | int e,c,len=type_length(s);
type_stack_mark();
for(e=0;e<len;e++)
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | {
|
2a6d26 | 1998-03-25 | Fredrik Hübinette (Hubbe) | | switch(c=EXTRACT_UCHAR(s+e))
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | {
|
2a6d26 | 1998-03-25 | Fredrik Hübinette (Hubbe) | | #if 1
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
if(am[c-'0'])
{
push_finished_type_backwards(am[c-'0']);
}else{
push_type(T_MIXED);
}
break;
#endif
case T_OBJECT:
push_type(c);
push_type(EXTRACT_UCHAR(s+ ++e));
push_type(EXTRACT_UCHAR(s+ ++e));
push_type(EXTRACT_UCHAR(s+ ++e));
push_type(EXTRACT_UCHAR(s+ ++e));
|
6bc928 | 1998-04-10 | Fredrik Hübinette (Hubbe) | | push_type(EXTRACT_UCHAR(s+ ++e));
|
2a6d26 | 1998-03-25 | Fredrik Hübinette (Hubbe) | | break;
default:
push_type(c);
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | }
}
|
2a6d26 | 1998-03-25 | Fredrik Hübinette (Hubbe) | | type_stack_reverse();
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | }
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | void push_finished_type(struct pike_string *type)
|
726071 | 1996-06-21 | Fredrik Hübinette (Hubbe) | | {
int e;
|
b9e4ba | 1996-11-18 | Fredrik Hübinette (Hubbe) | | CHECK_TYPE(type);
|
726071 | 1996-06-21 | Fredrik Hübinette (Hubbe) | | for(e=type->len-1;e>=0;e--) push_type(type->str[e]);
}
|
2a6d26 | 1998-03-25 | Fredrik Hübinette (Hubbe) | | void push_finished_type_backwards(struct pike_string *type)
{
int e;
CHECK_TYPE(type);
MEMCPY(type_stackp, type->str, type->len);
type_stackp+=type->len;
}
|
61e9a0 | 1998-01-25 | Fredrik Hübinette (Hubbe) | | struct pike_string *debug_pop_unfinished_type(void)
|
726071 | 1996-06-21 | Fredrik Hübinette (Hubbe) | | {
int len,e;
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | struct pike_string *s;
|
36feac | 1997-03-06 | Fredrik Hübinette (Hubbe) | | len=pop_stack_mark();
|
726071 | 1996-06-21 | Fredrik Hübinette (Hubbe) | | s=begin_shared_string(len);
|
36feac | 1997-03-06 | Fredrik Hübinette (Hubbe) | | type_stackp-=len;
MEMCPY(s->str, type_stackp, len);
reverse(s->str, len, 1);
|
b9e4ba | 1996-11-18 | Fredrik Hübinette (Hubbe) | | s=end_shared_string(s);
CHECK_TYPE(s);
return s;
|
726071 | 1996-06-21 | Fredrik Hübinette (Hubbe) | | }
|
61e9a0 | 1998-01-25 | Fredrik Hübinette (Hubbe) | | struct pike_string *debug_pop_type(void)
|
726071 | 1996-06-21 | Fredrik Hübinette (Hubbe) | | {
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | struct pike_string *s;
|
36feac | 1997-03-06 | Fredrik Hübinette (Hubbe) | | s=pop_unfinished_type();
type_stack_mark();
|
726071 | 1996-06-21 | Fredrik Hübinette (Hubbe) | | return s;
}
|
4142a6 | 1998-05-19 | Fredrik Hübinette (Hubbe) | | struct pike_string *debug_compiler_pop_type(void)
{
extern int num_parse_error;
if(num_parse_error)
{
pop_stack_mark();
type_stack_mark();
reference_shared_string(mixed_type_string);
return mixed_type_string;
}else{
struct pike_string *s;
s=pop_unfinished_type();
type_stack_mark();
return s;
}
}
|
b432bb | 1996-10-29 | Per Hedbor | | static void internal_parse_typeA(char **_s)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
f044a8 | 1996-12-06 | Fredrik Hübinette (Hubbe) | | char buf[80];
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | unsigned int len;
|
b432bb | 1996-10-29 | Per Hedbor | | unsigned char **s = (unsigned char **)_s;
|
bdb509 | 1996-09-25 | Fredrik Hübinette (Hubbe) | | while(ISSPACE(**s)) ++*s;
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
len=0;
|
f044a8 | 1996-12-06 | Fredrik Hübinette (Hubbe) | | for(len=0;isidchar(EXTRACT_UCHAR(s[0]+len));len++)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
if(len>=sizeof(buf)) error("Buffer overflow in parse_type\n");
buf[len] = s[0][len];
}
buf[len]=0;
*s += len;
|
134717 | 1998-04-23 | Fredrik Hübinette (Hubbe) | | switch(buf[0])
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
134717 | 1998-04-23 | Fredrik Hübinette (Hubbe) | | case 'i':
if(!strcmp(buf,"int")) { push_type(T_INT); break; }
goto bad_type;
case 'f':
if(!strcmp(buf,"function"))
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
134717 | 1998-04-23 | Fredrik Hübinette (Hubbe) | | while(ISSPACE(**s)) ++*s;
if(**s == '(')
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
134717 | 1998-04-23 | Fredrik Hübinette (Hubbe) | | ++*s;
while(ISSPACE(**s)) ++*s;
type_stack_mark();
while(1)
{
if(**s == ':')
{
push_type(T_MANY);
push_type(T_VOID);
break;
}
type_stack_mark();
type_stack_mark();
type_stack_mark();
internal_parse_type(_s);
type_stack_reverse();
if(**s==',')
{
++*s;
while(ISSPACE(**s)) ++*s;
}
else if(s[0][0]=='.' && s[0][1]=='.' && s[0][2]=='.')
{
type_stack_reverse();
push_type(T_MANY);
type_stack_reverse();
*s+=3;
while(ISSPACE(**s)) ++*s;
if(**s != ':') error("Missing ':' after ... in function type.\n");
break;
}
pop_stack_mark();
pop_stack_mark();
}
++*s;
type_stack_mark();
internal_parse_type(_s);
type_stack_reverse();
if(**s != ')') error("Missing ')' in function type.\n");
++*s;
type_stack_reverse();
}else{
push_type(T_MIXED);
push_type(T_MIXED);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | push_type(T_MANY);
}
|
134717 | 1998-04-23 | Fredrik Hübinette (Hubbe) | | push_type(T_FUNCTION);
break;
}
if(!strcmp(buf,"float")) { push_type(T_FLOAT); break; }
goto bad_type;
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
|
134717 | 1998-04-23 | Fredrik Hübinette (Hubbe) | | case 'o':
if(!strcmp(buf,"object"))
{
push_type_int(0);
push_type(0);
push_type(T_OBJECT);
break;
}
goto bad_type;
case 'p':
if(!strcmp(buf,"program")) { push_type(T_PROGRAM); break; }
goto bad_type;
case 's':
if(!strcmp(buf,"string")) { push_type(T_STRING); break; }
goto bad_type;
case 'v':
if(!strcmp(buf,"void")) { push_type(T_VOID); break; }
goto bad_type;
case 'm':
if(!strcmp(buf,"mixed")) { push_type(T_MIXED); break; }
if(!strcmp(buf,"mapping"))
{
while(ISSPACE(**s)) ++*s;
if(**s == '(')
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
134717 | 1998-04-23 | Fredrik Hübinette (Hubbe) | | type_stack_mark();
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | ++*s;
|
134717 | 1998-04-23 | Fredrik Hübinette (Hubbe) | | type_stack_mark();
internal_parse_type(_s);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | type_stack_reverse();
|
134717 | 1998-04-23 | Fredrik Hübinette (Hubbe) | | if(**s != ':') error("Expecting ':'.\n");
++*s;
type_stack_mark();
internal_parse_type(_s);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | type_stack_reverse();
|
134717 | 1998-04-23 | Fredrik Hübinette (Hubbe) | | if(**s != ')') error("Expecting ')'.\n");
++*s;
type_stack_reverse();
}else{
push_type(T_MIXED);
push_type(T_MIXED);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
|
134717 | 1998-04-23 | Fredrik Hübinette (Hubbe) | | push_type(T_MAPPING);
break;
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
|
134717 | 1998-04-23 | Fredrik Hübinette (Hubbe) | | if(!strcmp(buf,"multiset"))
{
while(ISSPACE(**s)) ++*s;
if(**s == '(')
{
++*s;
internal_parse_type(_s);
if(**s != ')') error("Expecting ')'.\n");
++*s;
}else{
push_type(T_MIXED);
}
push_type(T_MULTISET);
break;
}
goto bad_type;
case 'u':
if(!strcmp(buf,"unknown")) { push_type(T_UNKNOWN); break; }
goto bad_type;
case 'a':
if(!strcmp(buf,"array"))
{
while(ISSPACE(**s)) ++*s;
if(**s == '(')
{
++*s;
internal_parse_type(_s);
if(**s != ')') error("Expecting ')'.\n");
++*s;
}else{
push_type(T_MIXED);
}
push_type(T_ARRAY);
break;
}
goto bad_type;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
if(atoi(buf)<10)
{
while(ISSPACE(**s)) ++*s;
if(**s=='=')
{
++*s;
internal_parse_type(_s);
push_type(buf[0]);
push_type(T_ASSIGN);
}else{
push_type(buf[0]);
}
break;
}
default:
bad_type:
error("Couldn't parse type. (%s)\n",buf);
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | }
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
|
bdb509 | 1996-09-25 | Fredrik Hübinette (Hubbe) | | while(ISSPACE(**s)) ++*s;
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | }
static void internal_parse_typeB(char **s)
{
|
291600 | 1998-01-16 | Henrik Grubbström (Grubba) | | while(ISSPACE(**((unsigned char **)s))) ++*s;
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | switch(**s)
{
case '!':
++*s;
internal_parse_typeB(s);
push_type(T_NOT);
break;
case '(':
++*s;
|
a946c7 | 1998-03-02 | Fredrik Hübinette (Hubbe) | | internal_parse_type(s);
|
291600 | 1998-01-16 | Henrik Grubbström (Grubba) | | while(ISSPACE(**((unsigned char **)s))) ++*s;
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | if(**s != ')') error("Expecting ')'.\n");
break;
default:
internal_parse_typeA(s);
}
}
static void internal_parse_typeCC(char **s)
{
internal_parse_typeB(s);
|
291600 | 1998-01-16 | Henrik Grubbström (Grubba) | | while(ISSPACE(**((unsigned char **)s))) ++*s;
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | |
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | while(**s == '*')
{
++*s;
|
291600 | 1998-01-16 | Henrik Grubbström (Grubba) | | while(ISSPACE(**((unsigned char **)s))) ++*s;
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | push_type(T_ARRAY);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | }
static void internal_parse_typeC(char **s)
{
type_stack_mark();
type_stack_mark();
internal_parse_typeCC(s);
type_stack_reverse();
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
|
291600 | 1998-01-16 | Henrik Grubbström (Grubba) | | while(ISSPACE(**((unsigned char **)s))) ++*s;
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | |
if(**s == '&')
{
++*s;
type_stack_mark();
internal_parse_typeC(s);
type_stack_reverse();
type_stack_reverse();
push_type(T_AND);
}else{
type_stack_reverse();
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | }
static void internal_parse_type(char **s)
{
internal_parse_typeC(s);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
|
291600 | 1998-01-16 | Henrik Grubbström (Grubba) | | while(ISSPACE(**((unsigned char **)s))) ++*s;
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | |
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | while(**s == '|')
{
++*s;
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | internal_parse_typeC(s);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | push_type(T_OR);
}
}
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | * It takes a string on the exact same format as Pike and returns a type
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | * struct.
*/
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | struct pike_string *parse_type(char *s)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
36feac | 1997-03-06 | Fredrik Hübinette (Hubbe) | | type_stack_mark();
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | internal_parse_type(&s);
if( *s )
fatal("Extra junk at end of type definition.\n");
|
36feac | 1997-03-06 | Fredrik Hübinette (Hubbe) | | return pop_unfinished_type();
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
#ifdef DEBUG
void stupid_describe_type(char *a,INT32 len)
{
INT32 e;
for(e=0;e<len;e++)
{
if(e) printf(" ");
switch(EXTRACT_UCHAR(a+e))
{
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
printf("%c",EXTRACT_UCHAR(a+e));
break;
case T_ASSIGN: printf("="); break;
case T_INT: printf("int"); break;
case T_FLOAT: printf("float"); break;
case T_STRING: printf("string"); break;
case T_PROGRAM: printf("program"); break;
case T_OBJECT:
|
6bc928 | 1998-04-10 | Fredrik Hübinette (Hubbe) | | printf("object(%s %ld)",
|
134717 | 1998-04-23 | Fredrik Hübinette (Hubbe) | | EXTRACT_UCHAR(a+e+1)?"clone of":"inherits",
|
6bc928 | 1998-04-10 | Fredrik Hübinette (Hubbe) | | (long)EXTRACT_INT(a+e+2));
e+=sizeof(INT32)+1;
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | break;
case T_FUNCTION: printf("function"); break;
case T_ARRAY: printf("array"); break;
case T_MAPPING: printf("mapping"); break;
case T_MULTISET: printf("multiset"); break;
case T_UNKNOWN: printf("unknown"); break;
case T_MANY: printf("many"); break;
case T_OR: printf("or"); break;
case T_AND: printf("and"); break;
case T_NOT: printf("not"); break;
case T_VOID: printf("void"); break;
case T_MIXED: printf("mixed"); break;
default: printf("%d",EXTRACT_UCHAR(a+e)); break;
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
}
printf("\n");
}
|
0d202a | 1995-10-20 | Fredrik Hübinette (Hubbe) | |
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | void simple_describe_type(struct pike_string *s)
|
0d202a | 1995-10-20 | Fredrik Hübinette (Hubbe) | | {
stupid_describe_type(s->str,s->len);
}
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | #endif
char *low_describe_type(char *t)
{
switch(EXTRACT_UCHAR(t++))
{
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
my_putchar(EXTRACT_UCHAR(t-1));
break;
case T_ASSIGN:
my_putchar('(');
my_putchar(EXTRACT_UCHAR(t++));
my_putchar('=');
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | t=low_describe_type(t);
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | my_putchar(')');
break;
case T_VOID: my_strcat("void"); break;
case T_MIXED: my_strcat("mixed"); break;
case T_UNKNOWN: my_strcat("unknown"); break;
case T_INT: my_strcat("int"); break;
case T_FLOAT: my_strcat("float"); break;
case T_PROGRAM: my_strcat("program"); break;
case T_OBJECT:
|
0ee27b | 1998-04-14 | Fredrik Hübinette (Hubbe) | | if(EXTRACT_INT(t+1))
{
char buffer[100];
sprintf(buffer,"object(%s %ld)",*t?"is":"implements",(long)EXTRACT_INT(t+1));
my_strcat(buffer);
}else{
my_strcat("object");
}
|
6bc928 | 1998-04-10 | Fredrik Hübinette (Hubbe) | | t+=sizeof(INT32)+1;
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | |
break;
case T_STRING: my_strcat("string"); break;
case T_FUNCTION:
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | {
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | int s;
my_strcat("function(");
s=0;
while(EXTRACT_UCHAR(t) != T_MANY)
{
if(s++) my_strcat(", ");
t=low_describe_type(t);
}
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | t++;
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | if(EXTRACT_UCHAR(t) == T_VOID)
{
t++;
}else{
if(s++) my_strcat(", ");
t=low_describe_type(t);
my_strcat(" ...");
}
my_strcat(" : ");
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | t=low_describe_type(t);
my_strcat(")");
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | break;
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | }
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | case T_ARRAY:
|
5ac766 | 1998-04-28 | Fredrik Hübinette (Hubbe) | | my_strcat("array");
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | if(EXTRACT_UCHAR(t)==T_MIXED)
{
t++;
}else{
|
5ac766 | 1998-04-28 | Fredrik Hübinette (Hubbe) | | my_strcat("(");
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | t=low_describe_type(t);
|
5ac766 | 1998-04-28 | Fredrik Hübinette (Hubbe) | | my_strcat(")");
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | }
break;
case T_MULTISET:
my_strcat("multiset");
if(EXTRACT_UCHAR(t)!=T_MIXED)
{
my_strcat("(");
t=low_describe_type(t);
my_strcat(")");
}else{
t++;
}
break;
case T_NOT:
my_strcat("!");
t=low_describe_type(t);
break;
case T_OR:
t=low_describe_type(t);
my_strcat(" | ");
t=low_describe_type(t);
break;
case T_AND:
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | t=low_describe_type(t);
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | my_strcat(" & ");
t=low_describe_type(t);
break;
case T_MAPPING:
my_strcat("mapping");
if(EXTRACT_UCHAR(t)==T_MIXED && EXTRACT_UCHAR(t+1)==T_MIXED)
{
t+=2;
}else{
my_strcat("(");
t=low_describe_type(t);
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | my_strcat(":");
t=low_describe_type(t);
my_strcat(")");
}
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | break;
}
return t;
}
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | struct pike_string *describe_type(struct pike_string *type)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | if(!type) return make_shared_string("mixed");
init_buf();
low_describe_type(type->str);
return free_buf();
}
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | static int low_is_same_type(char *a, char *b)
{
if(type_length(a) != type_length(b)) return 0;
return !MEMCMP(a,b,type_length(a));
}
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | static TYPE_T low_compile_type_to_runtime_type(char *t)
{
TYPE_T tmp;
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | switch(EXTRACT_UCHAR(t))
{
case T_OR:
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | t++;
tmp=low_compile_type_to_runtime_type(t);
if(tmp == low_compile_type_to_runtime_type(t+type_length(t)))
return tmp;
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | default:
return T_MIXED;
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | case T_ARRAY:
case T_MAPPING:
case T_MULTISET:
case T_OBJECT:
case T_PROGRAM:
case T_FUNCTION:
case T_STRING:
case T_INT:
case T_FLOAT:
return EXTRACT_UCHAR(t);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
}
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | TYPE_T compile_type_to_runtime_type(struct pike_string *s)
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | {
return low_compile_type_to_runtime_type(s->str);
}
|
a946c7 | 1998-03-02 | Fredrik Hübinette (Hubbe) | |
static int low_find_exact_type_match(char *needle, char *haystack)
{
while(EXTRACT_UCHAR(haystack)==T_OR)
{
haystack++;
if(low_find_exact_type_match(needle, haystack))
return 1;
haystack+=type_length(haystack);
}
return low_is_same_type(needle, haystack);
}
static void very_low_or_pike_types(char *to_push, char *not_push)
{
while(EXTRACT_UCHAR(to_push)==T_OR)
{
to_push++;
very_low_or_pike_types(to_push, not_push);
to_push+=type_length(to_push);
}
if(!low_find_exact_type_match(to_push, not_push))
{
push_unfinished_type(to_push);
push_type(T_OR);
}
}
static void low_or_pike_types(char *t1, char *t2)
{
if(!t1)
{
if(!t2)
push_type(T_VOID);
else
push_unfinished_type(t2);
}
else if(!t2)
{
push_unfinished_type(t1);
}
else if(EXTRACT_UCHAR(t1)==T_MIXED || EXTRACT_UCHAR(t2)==T_MIXED)
{
push_type(T_MIXED);
}
else
{
push_unfinished_type(t1);
very_low_or_pike_types(t2,t1);
}
}
static void medium_or_pike_types(struct pike_string *a,
struct pike_string *b)
{
low_or_pike_types( a ? a->str : 0 , b ? b->str : 0 );
}
static struct pike_string *or_pike_types(struct pike_string *a,
struct pike_string *b)
{
type_stack_mark();
medium_or_pike_types(a,b);
return pop_unfinished_type();
}
|
6bc928 | 1998-04-10 | Fredrik Hübinette (Hubbe) | | static struct pike_string *low_object_lfun_type(char *t, short lfun)
{
struct program *p;
int i;
p=id_to_program(EXTRACT_INT(t+2));
if(!p) return 0;
|
134717 | 1998-04-23 | Fredrik Hübinette (Hubbe) | | i=FIND_LFUN(p, lfun);
if(i==-1) return 0;
|
0ee27b | 1998-04-14 | Fredrik Hübinette (Hubbe) | | return ID_FROM_INT(p, i)->type;
|
6bc928 | 1998-04-10 | Fredrik Hübinette (Hubbe) | | }
|
a946c7 | 1998-03-02 | Fredrik Hübinette (Hubbe) | |
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | #define A_EXACT 1
#define B_EXACT 2
|
5b4dd3 | 1998-02-23 | Fredrik Hübinette (Hubbe) | | #define NO_MAX_ARGS 4
|
5ac766 | 1998-04-28 | Fredrik Hübinette (Hubbe) | | #define NO_SHORTCUTS 8
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | |
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | static char *low_match_types(char *a,char *b, int flags)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
1d5328 | 1996-11-25 | Fredrik Hübinette (Hubbe) | | int correct_args;
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | char *ret;
if(a == b) return a;
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | switch(EXTRACT_UCHAR(a))
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | case T_AND:
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | a++;
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | ret=low_match_types(a,b,flags);
if(!ret) return 0;
a+=type_length(a);
return low_match_types(a,b,flags);
case T_OR:
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | a++;
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | ret=low_match_types(a,b,flags);
|
5ac766 | 1998-04-28 | Fredrik Hübinette (Hubbe) | | if(ret && !(flags & NO_SHORTCUTS)) return ret;
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | a+=type_length(a);
|
5ac766 | 1998-04-28 | Fredrik Hübinette (Hubbe) | | if(ret)
{
low_match_types(a,b,flags);
return ret;
}else{
return low_match_types(a,b,flags);
}
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | |
case T_NOT:
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | if(low_match_types(a+1,b,(flags ^ B_EXACT ) | NO_MAX_ARGS))
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | return 0;
return a;
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | |
case T_ASSIGN:
ret=low_match_types(a+2,b,flags);
|
a946c7 | 1998-03-02 | Fredrik Hübinette (Hubbe) | | if(ret && EXTRACT_UCHAR(b)!=T_VOID)
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | {
int m=EXTRACT_UCHAR(a+1)-'0';
|
a946c7 | 1998-03-02 | Fredrik Hübinette (Hubbe) | | type_stack_mark();
low_or_pike_types(a_markers[m] ? a_markers[m]->str : 0,b);
if(a_markers[m]) free_string(a_markers[m]);
a_markers[m]=pop_unfinished_type();
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | }
return ret;
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
{
int m=EXTRACT_UCHAR(a)-'0';
if(a_markers[m])
|
a946c7 | 1998-03-02 | Fredrik Hübinette (Hubbe) | | return low_match_types(a_markers[m]->str, b, flags);
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | else
return low_match_types(mixed_type_string->str, b, flags);
}
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | switch(EXTRACT_UCHAR(b))
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | case T_AND:
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | b++;
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | ret=low_match_types(a,b,flags);
if(!ret) return 0;
b+=type_length(b);
return low_match_types(a,b,flags);
case T_OR:
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | b++;
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | ret=low_match_types(a,b,flags);
|
5ac766 | 1998-04-28 | Fredrik Hübinette (Hubbe) | | if(ret && !(flags & NO_SHORTCUTS)) return ret;
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | b+=type_length(b);
|
5ac766 | 1998-04-28 | Fredrik Hübinette (Hubbe) | | if(ret)
{
low_match_types(a,b,flags);
return ret;
}else{
return low_match_types(a,b,flags);
}
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | |
case T_NOT:
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | if(low_match_types(a,b+1, (flags ^ A_EXACT ) | NO_MAX_ARGS))
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | return 0;
return a;
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | |
case T_ASSIGN:
ret=low_match_types(a,b+2,flags);
|
a946c7 | 1998-03-02 | Fredrik Hübinette (Hubbe) | | if(ret && EXTRACT_UCHAR(a)!=T_VOID)
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | {
int m=EXTRACT_UCHAR(b+1)-'0';
|
a946c7 | 1998-03-02 | Fredrik Hübinette (Hubbe) | | type_stack_mark();
low_or_pike_types(b_markers[m] ? b_markers[m]->str : 0,a);
if(b_markers[m]) free_string(b_markers[m]);
b_markers[m]=pop_unfinished_type();
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | }
return ret;
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
{
int m=EXTRACT_UCHAR(b)-'0';
if(b_markers[m])
|
a946c7 | 1998-03-02 | Fredrik Hübinette (Hubbe) | | return low_match_types(a, b_markers[m]->str, flags);
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | else
return low_match_types(a, mixed_type_string->str, flags);
}
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
|
0d202a | 1995-10-20 | Fredrik Hübinette (Hubbe) | |
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | if(EXTRACT_UCHAR(a) == T_MIXED && !(flags & A_EXACT)) return a;
if(EXTRACT_UCHAR(b) == T_MIXED && !(flags & B_EXACT)) return a;
|
d2c608 | 1996-11-07 | Fredrik Hübinette (Hubbe) | |
|
9f6847 | 1997-03-08 | Fredrik Hübinette (Hubbe) | |
switch(EXTRACT_TWOT(a,b))
|
255d35 | 1997-01-26 | Fredrik Hübinette (Hubbe) | | {
|
9f6847 | 1997-03-08 | Fredrik Hübinette (Hubbe) | | case TWOT(T_PROGRAM, T_FUNCTION):
case TWOT(T_FUNCTION, T_PROGRAM):
|
255d35 | 1997-01-26 | Fredrik Hübinette (Hubbe) | | return a;
|
9f6847 | 1997-03-08 | Fredrik Hübinette (Hubbe) | | case TWOT(T_OBJECT, T_FUNCTION):
|
d2c608 | 1996-11-07 | Fredrik Hübinette (Hubbe) | | {
|
6bc928 | 1998-04-10 | Fredrik Hübinette (Hubbe) | | struct pike_string *s;
if((s=low_object_lfun_type(a, LFUN_CALL)))
return low_match_types(s->str,b,flags);
|
d2c608 | 1996-11-07 | Fredrik Hübinette (Hubbe) | | return a;
}
|
9f6847 | 1997-03-08 | Fredrik Hübinette (Hubbe) | | case TWOT(T_FUNCTION, T_OBJECT):
{
|
6bc928 | 1998-04-10 | Fredrik Hübinette (Hubbe) | | struct pike_string *s;
if((s=low_object_lfun_type(b, LFUN_CALL)))
return low_match_types(a,s->str,flags);
|
9f6847 | 1997-03-08 | Fredrik Hübinette (Hubbe) | | return a;
}
}
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | if(EXTRACT_UCHAR(a) != EXTRACT_UCHAR(b)) return 0;
ret=a;
switch(EXTRACT_UCHAR(a))
{
case T_FUNCTION:
|
1d5328 | 1996-11-25 | Fredrik Hübinette (Hubbe) | | correct_args=0;
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | a++;
b++;
while(EXTRACT_UCHAR(a)!=T_MANY || EXTRACT_UCHAR(b)!=T_MANY)
{
char *a_tmp,*b_tmp;
if(EXTRACT_UCHAR(a)==T_MANY)
{
a_tmp=a+1;
}else{
a_tmp=a;
a+=type_length(a);
}
if(EXTRACT_UCHAR(b)==T_MANY)
{
|
0d202a | 1995-10-20 | Fredrik Hübinette (Hubbe) | | b_tmp=b+1;
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }else{
b_tmp=b;
b+=type_length(b);
}
|
5b4dd3 | 1998-02-23 | Fredrik Hübinette (Hubbe) | | if(!low_match_types(a_tmp, b_tmp, flags | NO_MAX_ARGS)) return 0;
|
1d5328 | 1996-11-25 | Fredrik Hübinette (Hubbe) | | if(++correct_args > max_correct_args)
|
5b4dd3 | 1998-02-23 | Fredrik Hübinette (Hubbe) | | if(!(flags & NO_MAX_ARGS))
max_correct_args=correct_args;
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
a++;
b++;
|
0d202a | 1995-10-20 | Fredrik Hübinette (Hubbe) | | if(EXTRACT_UCHAR(b)==T_VOID || EXTRACT_UCHAR(a)==T_VOID)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
a+=type_length(a);
|
0d202a | 1995-10-20 | Fredrik Hübinette (Hubbe) | | b+=type_length(b);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }else{
|
5b4dd3 | 1998-02-23 | Fredrik Hübinette (Hubbe) | | if(!low_match_types(a,b,flags | NO_MAX_ARGS)) return 0;
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
|
5b4dd3 | 1998-02-23 | Fredrik Hübinette (Hubbe) | | if(!(flags & NO_MAX_ARGS))
max_correct_args=0x7fffffff;
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | if(!low_match_types(a,b,flags)) return 0;
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | break;
case T_MAPPING:
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | if(!low_match_types(++a,++b,flags)) return 0;
if(!low_match_types(a+type_length(a),b+type_length(b),flags)) return 0;
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | break;
|
d2c608 | 1996-11-07 | Fredrik Hübinette (Hubbe) | | case T_OBJECT:
|
636e47 | 1998-04-15 | Fredrik Hübinette (Hubbe) | | #if 0
if(EXTRACT_INT(a+2) || EXTRACT_INT(b+2))
{
fprintf(stderr,"Type match1: ");
stupid_describe_type(a,type_length(a));
fprintf(stderr,"Type match2: ");
stupid_describe_type(b,type_length(b));
}
#endif
|
6bc928 | 1998-04-10 | Fredrik Hübinette (Hubbe) | |
if(!EXTRACT_INT(a+2) || !EXTRACT_INT(b+2)) break;
if(EXTRACT_UCHAR(a+1) == EXTRACT_UCHAR(b+1))
{
if(EXTRACT_UCHAR(a+1))
{
if(EXTRACT_INT(a+2) != EXTRACT_INT(b+2)) return 0;
}else{
break;
}
}
{
struct program *ap,*bp;
|
636e47 | 1998-04-15 | Fredrik Hübinette (Hubbe) | | ap=id_to_program(EXTRACT_INT(a+2));
bp=id_to_program(EXTRACT_INT(b+2));
|
6bc928 | 1998-04-10 | Fredrik Hübinette (Hubbe) | |
if(!ap || !bp) break;
|
636e47 | 1998-04-15 | Fredrik Hübinette (Hubbe) | |
|
6bc928 | 1998-04-10 | Fredrik Hübinette (Hubbe) | | if(EXTRACT_UCHAR(a+1))
{
|
0ee27b | 1998-04-14 | Fredrik Hübinette (Hubbe) | | if(!implements(ap,bp))
|
6bc928 | 1998-04-10 | Fredrik Hübinette (Hubbe) | | return 0;
}else{
|
0ee27b | 1998-04-14 | Fredrik Hübinette (Hubbe) | | if(!implements(bp,ap))
|
6bc928 | 1998-04-10 | Fredrik Hübinette (Hubbe) | | return 0;
}
}
|
d2c608 | 1996-11-07 | Fredrik Hübinette (Hubbe) | | break;
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | case T_MULTISET:
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | case T_ARRAY:
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | if(!low_match_types(++a,++b,flags)) return 0;
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
case T_INT:
case T_FLOAT:
case T_STRING:
case T_PROGRAM:
case T_VOID:
case T_MIXED:
break;
default:
fatal("error in type string.\n");
}
return ret;
}
static int low_get_return_type(char *a,char *b)
{
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | int tmp;
switch(EXTRACT_UCHAR(a))
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | case T_OR:
|
726071 | 1996-06-21 | Fredrik Hübinette (Hubbe) | | {
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | struct pike_string *o1,*o2;
|
726071 | 1996-06-21 | Fredrik Hübinette (Hubbe) | | a++;
o1=o2=0;
type_stack_mark();
if(low_get_return_type(a,b))
{
o1=pop_unfinished_type();
type_stack_mark();
}
if(low_get_return_type(a+type_length(a),b))
o2=pop_unfinished_type();
else
pop_stack_mark();
|
a946c7 | 1998-03-02 | Fredrik Hübinette (Hubbe) | | if(!o1 && !o2) return 0;
medium_or_pike_types(o1,o2);
|
726071 | 1996-06-21 | Fredrik Hübinette (Hubbe) | |
if(o1) free_string(o1);
if(o2) free_string(o2);
return 1;
}
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | case T_AND:
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | a++;
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | type_stack_mark();
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | tmp=low_get_return_type(a,b);
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | type_stack_pop_to_mark();
if(!tmp) return 0;
return low_get_return_type(a+type_length(a),b);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | case T_ARRAY:
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | a++;
tmp=low_get_return_type(a,b);
if(!tmp) return 0;
push_type(T_ARRAY);
return 1;
}
|
5ac766 | 1998-04-28 | Fredrik Hübinette (Hubbe) | | a=low_match_types(a,b,NO_SHORTCUTS);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | if(a)
{
switch(EXTRACT_UCHAR(a))
{
case T_FUNCTION:
a++;
while(EXTRACT_UCHAR(a)!=T_MANY) a+=type_length(a);
a++;
a+=type_length(a);
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | push_unfinished_type_with_markers(a, a_markers );
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | return 1;
|
d2c608 | 1996-11-07 | Fredrik Hübinette (Hubbe) | | case T_PROGRAM:
push_type_int(0);
|
6bc928 | 1998-04-10 | Fredrik Hübinette (Hubbe) | | push_type(0);
|
d2c608 | 1996-11-07 | Fredrik Hübinette (Hubbe) | | push_type(T_OBJECT);
return 1;
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | default:
push_type(T_MIXED);
return 1;
}
}
return 0;
}
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | int match_types(struct pike_string *a,struct pike_string *b)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
b9e4ba | 1996-11-18 | Fredrik Hübinette (Hubbe) | | CHECK_TYPE(a);
CHECK_TYPE(b);
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | clear_markers();
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | return 0!=low_match_types(a->str, b->str,0);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
|
2a5096 | 1995-08-23 | Fredrik Hübinette (Hubbe) | |
|
3c0c28 | 1998-01-26 | Fredrik Hübinette (Hubbe) | | #ifdef DEBUG_MALLOC
#define low_index_type(X,Y) ((struct pike_string *)debug_malloc_touch(debug_low_index_type((X),(Y))))
#else
#define low_index_type debug_low_index_type
#endif
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
|
3c0c28 | 1998-01-26 | Fredrik Hübinette (Hubbe) | | static struct pike_string *debug_low_index_type(char *t, node *n)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
switch(EXTRACT_UCHAR(t++))
{
|
b8cda2 | 1997-01-21 | Fredrik Hübinette (Hubbe) | | case T_OBJECT:
{
|
6bc928 | 1998-04-10 | Fredrik Hübinette (Hubbe) | | struct program *p=id_to_program(EXTRACT_INT(t+1));
|
dcab7e | 1998-02-19 | Fredrik Hübinette (Hubbe) | | if(p && n)
|
b8cda2 | 1997-01-21 | Fredrik Hübinette (Hubbe) | | {
if(n->token == F_ARROW)
{
|
b1f4eb | 1998-01-13 | Fredrik Hübinette (Hubbe) | | if(FIND_LFUN(p,LFUN_ARROW)!=-1 || FIND_LFUN(p,LFUN_ASSIGN_ARROW)!=-1)
|
b8cda2 | 1997-01-21 | Fredrik Hübinette (Hubbe) | | {
reference_shared_string(mixed_type_string);
return mixed_type_string;
}
}else{
|
b1f4eb | 1998-01-13 | Fredrik Hübinette (Hubbe) | | if(FIND_LFUN(p,LFUN_INDEX) != -1 || FIND_LFUN(p,LFUN_ASSIGN_INDEX) != -1)
|
b8cda2 | 1997-01-21 | Fredrik Hübinette (Hubbe) | | {
reference_shared_string(mixed_type_string);
return mixed_type_string;
}
}
if(CDR(n)->token == F_CONSTANT && CDR(n)->u.sval.type==T_STRING)
{
INT32 i;
i=find_shared_string_identifier(CDR(n)->u.sval.u.string, p);
if(i==-1)
{
|
b8c29a | 1998-08-19 | Fredrik Hübinette (Hubbe) | | reference_shared_string(mixed_type_string);
return mixed_type_string;
|
b8cda2 | 1997-01-21 | Fredrik Hübinette (Hubbe) | | }else{
|
6bc928 | 1998-04-10 | Fredrik Hübinette (Hubbe) | | if(EXTRACT_UCHAR(t) ||
(p->identifier_references[i].id_flags & ID_NOMASK) ||
(ID_FROM_INT(p, i)->identifier_flags & IDENTIFIER_PROTOTYPED))
{
reference_shared_string(ID_FROM_INT(p, i)->type);
return ID_FROM_INT(p, i)->type;
}else{
reference_shared_string(mixed_type_string);
return mixed_type_string;
}
|
b8cda2 | 1997-01-21 | Fredrik Hübinette (Hubbe) | | }
}
}
}
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | default:
reference_shared_string(mixed_type_string);
return mixed_type_string;
case T_OR:
{
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | struct pike_string *a,*b;
|
36feac | 1997-03-06 | Fredrik Hübinette (Hubbe) | | type_stack_mark();
|
b8cda2 | 1997-01-21 | Fredrik Hübinette (Hubbe) | | a=low_index_type(t,n);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | t+=type_length(t);
|
b8cda2 | 1997-01-21 | Fredrik Hübinette (Hubbe) | | b=low_index_type(t,n);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | if(!b) return a;
if(!a) return b;
|
a946c7 | 1998-03-02 | Fredrik Hübinette (Hubbe) | | type_stack_mark();
medium_or_pike_types(a,b);
|
3c0c28 | 1998-01-26 | Fredrik Hübinette (Hubbe) | | free_string(a);
free_string(b);
|
36feac | 1997-03-06 | Fredrik Hübinette (Hubbe) | | return pop_unfinished_type();
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | case T_AND:
|
b8cda2 | 1997-01-21 | Fredrik Hübinette (Hubbe) | | return low_index_type(t+type_length(t),n);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
case T_STRING:
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | case T_MULTISET:
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | reference_shared_string(int_type_string);
return int_type_string;
case T_MAPPING:
t+=type_length(t);
|
de2a58 | 1997-09-28 | Fredrik Hübinette (Hubbe) | | return make_shared_binary_string(t, type_length(t));
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
case T_ARRAY:
|
dcab7e | 1998-02-19 | Fredrik Hübinette (Hubbe) | | if(n && low_match_types(string_type_string->str,CDR(n)->type->str,0))
|
de2a58 | 1997-09-28 | Fredrik Hübinette (Hubbe) | | {
struct pike_string *a=low_index_type(t,n);
if(!a)
return make_shared_binary_string(t, type_length(t));
type_stack_mark();
push_finished_type(a);
free_string(a);
push_type(T_ARRAY);
if(low_match_types(int_type_string->str,CDR(n)->type->str,0))
{
push_unfinished_type(t);
|
a946c7 | 1998-03-02 | Fredrik Hübinette (Hubbe) | | push_type(T_OR);
|
de2a58 | 1997-09-28 | Fredrik Hübinette (Hubbe) | | }
return pop_unfinished_type();
}else{
return make_shared_binary_string(t, type_length(t));
}
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
}
|
b8cda2 | 1997-01-21 | Fredrik Hübinette (Hubbe) | | struct pike_string *index_type(struct pike_string *type, node *n)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | struct pike_string *t;
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | clear_markers();
|
b8cda2 | 1997-01-21 | Fredrik Hübinette (Hubbe) | | t=low_index_type(type->str,n);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | if(!t) copy_shared_string(t,mixed_type_string);
return t;
}
|
b8cda2 | 1997-01-21 | Fredrik Hübinette (Hubbe) | | static int low_check_indexing(char *type, char *index_type, node *n)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
switch(EXTRACT_UCHAR(type++))
{
case T_OR:
|
b8cda2 | 1997-01-21 | Fredrik Hübinette (Hubbe) | | return low_check_indexing(type,index_type,n) ||
low_check_indexing(type+type_length(type),index_type,n);
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | |
case T_AND:
|
b8cda2 | 1997-01-21 | Fredrik Hübinette (Hubbe) | | return low_check_indexing(type,index_type,n) &&
low_check_indexing(type+type_length(type),index_type,n);
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | |
case T_NOT:
|
b8cda2 | 1997-01-21 | Fredrik Hübinette (Hubbe) | | return !low_check_indexing(type,index_type,n);
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | |
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | case T_ARRAY:
|
de2a58 | 1997-09-28 | Fredrik Hübinette (Hubbe) | | if(low_match_types(string_type_string->str, index_type,0) &&
low_check_indexing(type, index_type,n))
return 1;
case T_STRING:
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | return !!low_match_types(int_type_string->str, index_type,0);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
case T_OBJECT:
|
b8cda2 | 1997-01-21 | Fredrik Hübinette (Hubbe) | | {
|
6bc928 | 1998-04-10 | Fredrik Hübinette (Hubbe) | | struct program *p=id_to_program(EXTRACT_INT(type+1));
|
b8cda2 | 1997-01-21 | Fredrik Hübinette (Hubbe) | | if(p)
{
if(n->token == F_ARROW)
{
|
6bc928 | 1998-04-10 | Fredrik Hübinette (Hubbe) | | if(FIND_LFUN(p,LFUN_ARROW)!=-1 || FIND_LFUN(p,LFUN_ASSIGN_ARROW)!=-1)
return 1;
|
b8cda2 | 1997-01-21 | Fredrik Hübinette (Hubbe) | | }else{
|
6bc928 | 1998-04-10 | Fredrik Hübinette (Hubbe) | | if(FIND_LFUN(p,LFUN_INDEX)!=-1 || FIND_LFUN(p,LFUN_ASSIGN_INDEX)!=-1)
return 1;
|
b8cda2 | 1997-01-21 | Fredrik Hübinette (Hubbe) | | }
return !!low_match_types(string_type_string->str, index_type,0);
}else{
return 1;
}
}
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | case T_MULTISET:
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | case T_MAPPING:
|
bce86c | 1996-02-25 | Fredrik Hübinette (Hubbe) | | return !!low_match_types(type,index_type,0);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
|
43f12e | 1998-09-29 | Henrik Grubbström (Grubba) | | case T_PROGRAM:
|
c7e132 | 1998-10-28 | Henrik Grubbström (Grubba) | |
|
43f12e | 1998-09-29 | Henrik Grubbström (Grubba) | | return 1;
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | case T_MIXED:
return 1;
default:
return 0;
}
}
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | int check_indexing(struct pike_string *type,
|
b8cda2 | 1997-01-21 | Fredrik Hübinette (Hubbe) | | struct pike_string *index_type,
node *n)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
b9e4ba | 1996-11-18 | Fredrik Hübinette (Hubbe) | | CHECK_TYPE(type);
CHECK_TYPE(index_type);
|
b8cda2 | 1997-01-21 | Fredrik Hübinette (Hubbe) | | return low_check_indexing(type->str, index_type->str, n);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
|
5b4dd3 | 1998-02-23 | Fredrik Hübinette (Hubbe) | | static int low_count_arguments(char *q)
{
int num,num2;
|
d429a7 | 1998-02-24 | Fredrik Hübinette (Hubbe) | |
|
5b4dd3 | 1998-02-23 | Fredrik Hübinette (Hubbe) | | switch(EXTRACT_UCHAR(q++))
{
case T_OR:
num=low_count_arguments(q);
num2=low_count_arguments(q+type_length(q));
if(num<0 && num2>0) return num;
if(num2<0 && num>0) return num2;
if(num2<0 && num<0) return ~num>~num2?num:num2;
return num>num2?num:num2;
case T_AND:
num=low_count_arguments(q);
num2=low_count_arguments(q+type_length(q));
if(num<0 && num2>0) return num2;
if(num2<0 && num>0) return num;
if(num2<0 && num<0) return ~num<~num2?num:num2;
return num<num2?num:num2;
|
d429a7 | 1998-02-24 | Fredrik Hübinette (Hubbe) | | default: return 0x7fffffff;
|
5b4dd3 | 1998-02-23 | Fredrik Hübinette (Hubbe) | |
case T_FUNCTION:
num=0;
while(EXTRACT_UCHAR(q)!=T_MANY)
{
num++;
q+=type_length(q);
}
q++;
if(EXTRACT_UCHAR(q)!=T_VOID) return ~num;
return num;
}
}
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | int count_arguments(struct pike_string *s)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
b9e4ba | 1996-11-18 | Fredrik Hübinette (Hubbe) | | CHECK_TYPE(s);
|
5b4dd3 | 1998-02-23 | Fredrik Hübinette (Hubbe) | | return low_count_arguments(s->str);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | struct pike_string *check_call(struct pike_string *args,
|
1d5328 | 1996-11-25 | Fredrik Hübinette (Hubbe) | | struct pike_string *type)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
b9e4ba | 1996-11-18 | Fredrik Hübinette (Hubbe) | | CHECK_TYPE(args);
CHECK_TYPE(type);
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | clear_markers();
|
36feac | 1997-03-06 | Fredrik Hübinette (Hubbe) | | type_stack_mark();
|
1d5328 | 1996-11-25 | Fredrik Hübinette (Hubbe) | | max_correct_args=0;
|
36feac | 1997-03-06 | Fredrik Hübinette (Hubbe) | |
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | if(low_get_return_type(type->str,args->str))
{
|
36feac | 1997-03-06 | Fredrik Hübinette (Hubbe) | | return pop_unfinished_type();
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }else{
|
36feac | 1997-03-06 | Fredrik Hübinette (Hubbe) | | pop_stack_mark();
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | return 0;
}
}
|
5b4dd3 | 1998-02-23 | Fredrik Hübinette (Hubbe) | | INT32 get_max_args(struct pike_string *type)
{
INT32 ret,tmp=max_correct_args;
CHECK_TYPE(type);
|
9e5238 | 1998-03-01 | Fredrik Hübinette (Hubbe) | | clear_markers();
|
5b4dd3 | 1998-02-23 | Fredrik Hübinette (Hubbe) | | type=check_call(function_type_string, type);
if(type) free_string(type);
ret=max_correct_args;
max_correct_args=tmp;
return tmp;
}
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | struct pike_string *get_type_of_svalue(struct svalue *s)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | struct pike_string *ret;
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | switch(s->type)
{
case T_FUNCTION:
|
bdb509 | 1996-09-25 | Fredrik Hübinette (Hubbe) | | if(s->subtype == FUNCTION_BUILTIN)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
ret=s->u.efun->type;
}else{
struct program *p;
p=s->u.object->prog;
if(!p)
{
ret=int_type_string;
}else{
ret=ID_FROM_INT(p,s->subtype)->type;
}
}
reference_shared_string(ret);
return ret;
case T_ARRAY:
|
3db32a | 1997-03-04 | Fredrik Hübinette (Hubbe) | | type_stack_mark();
push_type(T_MIXED);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | push_type(T_ARRAY);
|
3db32a | 1997-03-04 | Fredrik Hübinette (Hubbe) | | return pop_unfinished_type();
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | case T_MULTISET:
|
3db32a | 1997-03-04 | Fredrik Hübinette (Hubbe) | | type_stack_mark();
push_type(T_MIXED);
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | push_type(T_MULTISET);
|
3db32a | 1997-03-04 | Fredrik Hübinette (Hubbe) | | return pop_unfinished_type();
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
case T_MAPPING:
|
3db32a | 1997-03-04 | Fredrik Hübinette (Hubbe) | | type_stack_mark();
|
6557ff | 1996-06-09 | Fredrik Hübinette (Hubbe) | | push_type(T_MIXED);
push_type(T_MIXED);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | push_type(T_MAPPING);
|
3db32a | 1997-03-04 | Fredrik Hübinette (Hubbe) | | return pop_unfinished_type();
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
|
041a73 | 1996-11-12 | Mirar (Pontus Hagland) | | case T_OBJECT:
|
3db32a | 1997-03-04 | Fredrik Hübinette (Hubbe) | | type_stack_mark();
if(s->u.object->prog)
{
push_type_int(s->u.object->prog->id);
|
6bc928 | 1998-04-10 | Fredrik Hübinette (Hubbe) | | push_type(1);
|
3db32a | 1997-03-04 | Fredrik Hübinette (Hubbe) | | }else{
push_type_int(0);
|
6bc928 | 1998-04-10 | Fredrik Hübinette (Hubbe) | | push_type(0);
|
3db32a | 1997-03-04 | Fredrik Hübinette (Hubbe) | | }
|
041a73 | 1996-11-12 | Mirar (Pontus Hagland) | | push_type(T_OBJECT);
|
3db32a | 1997-03-04 | Fredrik Hübinette (Hubbe) | | return pop_unfinished_type();
|
041a73 | 1996-11-12 | Mirar (Pontus Hagland) | |
|
e82b30 | 1997-01-29 | Fredrik Hübinette (Hubbe) | | case T_INT:
if(s->u.integer)
{
ret=int_type_string;
}else{
ret=mixed_type_string;
}
reference_shared_string(ret);
return ret;
|
9f6847 | 1997-03-08 | Fredrik Hübinette (Hubbe) | | case T_PROGRAM:
{
char *a;
|
b1f4eb | 1998-01-13 | Fredrik Hübinette (Hubbe) | | int id=FIND_LFUN(s->u.program,LFUN_CREATE);
|
9f6847 | 1997-03-08 | Fredrik Hübinette (Hubbe) | | if(id>=0)
{
a=ID_FROM_INT(s->u.program, id)->type->str;
}else{
a=function_type_string->str;
}
if(EXTRACT_UCHAR(a)==T_FUNCTION)
{
type_stack_mark();
push_type_int(s->u.program->id);
|
6bc928 | 1998-04-10 | Fredrik Hübinette (Hubbe) | | push_type(1);
|
9f6847 | 1997-03-08 | Fredrik Hübinette (Hubbe) | | push_type(T_OBJECT);
type_stack_mark();
a++;
while(EXTRACT_UCHAR(a)!=T_MANY)
{
type_stack_mark();
push_unfinished_type(a);
type_stack_reverse();
a+=type_length(a);
}
a++;
push_type(T_MANY);
type_stack_mark();
push_unfinished_type(a);
type_stack_reverse();
type_stack_reverse();
push_type(T_FUNCTION);
return pop_unfinished_type();
}
}
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | default:
|
3db32a | 1997-03-04 | Fredrik Hübinette (Hubbe) | | type_stack_mark();
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | push_type(s->type);
|
3db32a | 1997-03-04 | Fredrik Hübinette (Hubbe) | | return pop_unfinished_type();
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
}
char *get_name_of_type(int t)
{
switch(t)
{
case T_ARRAY: return "array";
|
45c897 | 1997-01-03 | Fredrik Hübinette (Hubbe) | | case T_FLOAT: return "float";
case T_FUNCTION: return "function";
case T_INT: return "int";
case T_LVALUE: return "lvalue";
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | case T_MAPPING: return "mapping";
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | case T_MULTISET: return "multiset";
|
45c897 | 1997-01-03 | Fredrik Hübinette (Hubbe) | | case T_OBJECT: return "object";
case T_PROGRAM: return "program";
case T_STRING: return "string";
|
3c04e8 | 1997-03-13 | Fredrik Hübinette (Hubbe) | | case T_VOID: return "void";
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | default: return "unknown";
}
}
|
be478c | 1997-08-30 | Henrik Grubbström (Grubba) | | void cleanup_pike_types(void)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
free_string(string_type_string);
free_string(int_type_string);
free_string(float_type_string);
free_string(function_type_string);
free_string(object_type_string);
free_string(program_type_string);
free_string(array_type_string);
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | free_string(multiset_type_string);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | free_string(mapping_type_string);
free_string(mixed_type_string);
free_string(void_type_string);
|
f6f02d | 1995-10-16 | Fredrik Hübinette (Hubbe) | | free_string(any_type_string);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
|
b47790 | 1998-06-05 | Fredrik Hübinette (Hubbe) | |
int type_may_overload(char *type, int lfun)
{
switch(EXTRACT_UCHAR(type++))
{
case T_ASSIGN:
return type_may_overload(type+1,lfun);
case T_FUNCTION:
case T_ARRAY:
default:
return 0;
case T_OR:
return type_may_overload(type,lfun) ||
type_may_overload(type+type_length(type),lfun);
case T_AND:
return type_may_overload(type,lfun) &&
type_may_overload(type+type_length(type),lfun);
case T_NOT:
return !type_may_overload(type,lfun);
case T_MIXED:
return 1;
case T_OBJECT:
{
struct program *p=id_to_program(EXTRACT_INT(type+1));
if(!p) return 1;
return FIND_LFUN(p, lfun)!=-1;
}
}
}
|