pike.git / src / lex.c

version» Context lines:

pike.git/src/lex.c:1:   /*\   ||| This file a part of Pike, and is copyright by Fredrik Hubinette   ||| Pike is distributed as GPL (General Public License)   ||| See the files COPYING and DISCLAIMER for more information.   \*/   #include "global.h" - RCSID("$Id: lex.c,v 1.25 1997/07/24 02:46:51 hubbe Exp $"); + RCSID("$Id: lex.c,v 1.26 1997/08/30 18:35:39 grubba Exp $");   #include "language.h"   #include "array.h"   #include "lex.h"   #include "stralloc.h"   #include "dynamic_buffer.h"   #include "constants.h"   #include "hashtable.h"   #include "stuff.h"   #include "pike_memory.h"   #include "interpret.h"
pike.git/src/lex.c:45:      struct pike_predef_s   {    char *name;    char *value;    struct pike_predef_s *next;   };      struct pike_predef_s *pike_predefs=0;    - static int calc(); - static void calc1(); + static int calc(void); + static void calc1(void);    - void exit_lex() + void exit_lex(void)   {   #ifdef DEBUG    if(p_flag)    {    int e;    fprintf(stderr,"Opcode usage: (opcode, runned, compiled)\n");    for(e=0;e<F_MAX_OPCODE-F_OFFSET;e++)    {    fprintf(stderr,":: %-20s %8ld %8ld\n",    low_get_f_name(e+F_OFFSET,0),
pike.git/src/lex.c:288:   struct instr instrs[F_MAX_INSTR - F_OFFSET];      struct reserved   {    struct hash_entry link;    int token;   };      struct hash_table *reswords;    - void init_lex() + void init_lex(void)   {    unsigned int i;    for(i=0; i<NELEM(instr_names);i++)    {    if(instr_names[i].token >= F_MAX_INSTR)    fatal("Error in instr_names[%u]\n\n",i);       if(instrs[instr_names[i].token - F_OFFSET].name)    fatal("Duplicate name for %s\n",instr_names[i].word);   
pike.git/src/lex.c:317:    struct reserved *r=ALLOC_STRUCT(reserved);    r->token = reserved_words[i].token;    r->link.s = make_shared_string(reserved_words[i].word);    reswords=hash_insert(reswords, &r->link);    }       /* Enlarge this hashtable heruetically */    reswords = hash_rehash(reswords, 2<<my_log2(NELEM(reserved_words)));   }    - void free_reswords() + void free_reswords(void)   {    free_hashtable(reswords,0);   }      char *low_get_f_name(int n,struct program *p)   {    static char buf[30];       if (n<F_MAX_OPCODE && instrs[n-F_OFFSET].name)    {
pike.git/src/lex.c:404:   /*** input routines ***/   struct inputstate   {    struct inputstate *next;    int fd;    unsigned char *data;    INT32 buflen;    INT32 pos;    int dont_free_data;    -  int (*my_getc)(); +  int (*my_getc)(void);    int (*gobble)(int); -  int (*look)(); +  int (*look)(void);    void (*my_ungetc)(int);    void (*ungetstr)(char *,INT32);   };      #define MY_EOF 4711      struct inputstate *istate=NULL;      static void link_inputstate(struct inputstate *i)   {
pike.git/src/lex.c:436:    retry:    if(close(i->fd)< 0)    if(errno == EINTR)    goto retry;    }    if(i->data && !i->dont_free_data) free(i->data);    free_inputstate(i->next);    free((char *)i);   }    - static struct inputstate *new_inputstate(); + static struct inputstate *new_inputstate(void);   static struct inputstate *memory_inputstate(INT32 size);      static int default_gobble(int c)   {    if(istate->look()==c)    {    istate->my_getc();    return 1;    }else{    return 0;
pike.git/src/lex.c:462:    link_inputstate(memory_inputstate(len+1000));    istate->ungetstr(s,len);   }      static void default_ungetc(int s)   {    char c=s;    istate->ungetstr(&c,1);   }    - static int default_look() + static int default_look(void)   {    int c;    c=istate->my_getc();    istate->my_ungetc(c);    return c;   }    - static struct inputstate *new_inputstate() + static struct inputstate *new_inputstate(void)   {    struct inputstate *i;    i=(struct inputstate *)xalloc(sizeof(struct inputstate));    i->fd=-1;    i->data=NULL;    i->next=NULL;    i->dont_free_data=0;    i->gobble=default_gobble;    i->ungetstr=default_ungetstr;    i->my_ungetc=default_ungetc;    i->look=default_look;    return i;   }      /*** end of file input ***/ - static int end_getc() { return MY_EOF; } + static int end_getc(void) { return MY_EOF; }   static int end_gobble(int c) { return c==MY_EOF; }   static void end_ungetc(int c)   {    if(c==MY_EOF) return;    default_ungetc(c);   }    - static struct inputstate *end_inputstate() + static struct inputstate *end_inputstate(void)   {    struct inputstate *i;    i=new_inputstate();    i->gobble=end_gobble;    i->look=end_getc;    i->my_getc=end_getc;    i->my_ungetc=end_ungetc;    return i;   }   
pike.git/src/lex.c:530:   {    if(istate->pos)    {    istate->pos --;    istate->data[istate->pos]=s;    }else{    default_ungetc(s);    }   }    - static int memory_getc() + static int memory_getc(void)   {    if(istate->pos<istate->buflen)    {   #if LEXDEBUG>9    fprintf(stderr,"lex: reading from memory '%c' (%d).\n",istate->data[istate->pos],istate->data[istate->pos]);   #endif    return istate->data[(istate->pos)++];    }else{    struct inputstate *i;    i=istate;    istate=i->next;    if(!i->dont_free_data) free(i->data);    free((char *)i);    return istate->my_getc();    }   }    - static int memory_look() + static int memory_look(void)   {    if(istate->pos<istate->buflen)    {    return istate->data[istate->pos];    }else{    struct inputstate *i;    i=istate;    istate=i->next;    if(!i->dont_free_data) free(i->data);    free((char *)i);
pike.git/src/lex.c:623:    i->my_getc=memory_getc;    i->look=memory_look;    i->ungetstr=prot_memory_ungetstr;    i->my_ungetc=prot_memory_ungetc;    return i;   }      /*** FILE input ***/      #define READAHEAD 8192 - static int file_getc() + static int file_getc(void)   {    unsigned char buf[READAHEAD];    int got;    do {    got=read(istate->fd, buf, READAHEAD);    if(got > 0)    {    default_ungetstr((char *)buf, got);    return istate->my_getc();    }
pike.git/src/lex.c:658:      static struct inputstate *file_inputstate(int fd)   {    struct inputstate *i;    i=new_inputstate();    i->fd=fd;    i->my_getc=file_getc;    return i;   }    - static int GETC() + static int GETC(void)   {    int c;    c=istate->my_getc();    if(c=='\n') current_line++;    return c;   }      static void UNGETC(int c)   {    if(c=='\n') current_line--;
pike.git/src/lex.c:713:    buf[p]=0; \   }      static char buf[1024];      /*** Define handling ***/      struct define   {    struct hash_entry link; /* must be first */ -  void (*magic)(); +  void (*magic)(void);    int args;    struct array *parts;   };      struct hash_table *defines = 0;      #define find_define(N) (defines?BASEOF(hash_lookup(defines, N), define, link):0)      /* argument must be shared string */   static void undefine(struct pike_string *name)
pike.git/src/lex.c:741:    defines=hash_unlink(defines, & d->link);    free_string(d->link.s);    free_array(d->parts);    free((char *)d);   }      /* name and as are supposed to be SHARED strings */   static void add_define(struct pike_string *name,    int args,    int parts_on_stack, -  void (*magic)()) +  void (*magic)(void))   {    struct define *d;       f_aggregate(parts_on_stack);    if(sp[-1].type != T_ARRAY)    {    yyerror("Define failed for unknown reason.\n");    free_string(name);    pop_stack();    return;
pike.git/src/lex.c:776:    d=(struct define *)xalloc(sizeof(struct define));    d->link.s=name;    d->args=args;    d->magic=magic;    d->parts=sp[-1].u.array;    sp--;       defines=hash_insert(defines, & d->link);   }    - static void simple_add_define(char *name,char *as,void (*magic)()) + static void simple_add_define(char *name,char *as,void (*magic)(void))   {    if(magic)    {    add_define(make_shared_string(name),-1,0,magic);    }else{    push_string(make_shared_string(as));    add_define(make_shared_string(name),-1,1,magic);    }   }      void free_one_define(struct hash_entry *h)   {    struct define *d;    d=BASEOF(h, define, link);    if(d->parts) free_array(d->parts);    free((void *)d);   }    - static void free_all_defines() + static void free_all_defines(void)   {    if(defines)    free_hashtable(defines, free_one_define);    defines=0;   }    - static void do_define() + static void do_define(void)   {    int c,e,t,argc;    struct svalue *save_sp=sp;    struct svalue *args_sp;    struct pike_string *s, *s2;       SKIPWHITE();    READBUF(isidchar(C));       s=make_shared_string(buf);
pike.git/src/lex.c:1060:    old_line=current_line=1;    free_string(current_file);    current_file=sp[-1].u.string;    sp--;    link_inputstate(file_inputstate(fd));    UNGETSTR("\n",1);   }      /*** Lexical analyzing ***/    - static int char_const() + static int char_const(void)   {    int c;    switch(c=GETC())    {    case '0': case '1': case '2': case '3':    case '4': case '5': case '6': case '7':    c-='0';    if(LOOK()<'0' || LOOK()>'8') return c;    c=c*8+(GETC()-'0');    if(LOOK()<'0' || LOOK()>'8') return c;
pike.git/src/lex.c:1764: Inside #if defined(__CHECKER__)
  {   #ifdef __CHECKER__    MEMSET((char *)yylval,0,sizeof(YYSTYPE));   #endif    return do_lex(0, yylval);   }      static YYSTYPE my_yylval;   static int lookahead;    - static void low_lex() + static void low_lex(void)   {    while(1)    {    struct pike_string *s;       lookahead=do_lex(1, &my_yylval);    if(lookahead == F_IDENTIFIER)    {    if(!strcmp("defined",my_yylval.str))    {
pike.git/src/lex.c:1831:    s=findstring(my_yylval.str);    if(!s || !expand_define(s,1))    UNGETSTR(" 0 ",3);    continue;    }       break;    }   }    - static void calcC() + static void calcC(void)   {    switch(lookahead)    {    case '(':    low_lex();    calc1();    if(lookahead != ')')    error("Missing ')'\n");    break;   
pike.git/src/lex.c:1874:    low_lex();    calc1();    f_index(2);    if(lookahead!=']')    error("Missing ']'\n");    else    low_lex();    }   }    - static void calcB() + static void calcB(void)   {    switch(lookahead)    {    case '-': low_lex(); calcB(); o_negate(); break;    case F_NOT: low_lex(); calcB(); o_not(); break;    case '~': low_lex(); calcB(); o_compl(); break;    default: calcC();    }   }    - static void calcA() + static void calcA(void)   {    calcB();    while(1)    {    switch(lookahead)    {    case '/': low_lex(); calcB(); o_divide(); continue;    case '*': low_lex(); calcB(); o_multiply(); continue;    case '%': low_lex(); calcB(); o_mod(); continue;    }    break;    }   }    - static void calc9() + static void calc9(void)   {    calcA();       while(1)    {    switch(lookahead)    {    case '+': low_lex(); calcA(); f_add(2); continue;    case '-': low_lex(); calcA(); o_subtract(); continue;    }    break;    }   }    - static void calc8() + static void calc8(void)   {    calc9();       while(1)    {    switch(lookahead)    {    case F_LSH: low_lex(); calc9(); o_lsh(); continue;    case F_RSH: low_lex(); calc9(); o_rsh(); continue;    }    break;    }   }    - static void calc7b() + static void calc7b(void)   {    calc8();       while(1)    {    switch(lookahead)    {    case '<': low_lex(); calc8(); f_lt(2); continue;    case '>': low_lex(); calc8(); f_gt(2); continue;    case F_GE: low_lex(); calc8(); f_ge(2); continue;    case F_LE: low_lex(); calc8(); f_le(2); continue;    }    break;    }   }    - static void calc7() + static void calc7(void)   {    calc7b();       while(1)    {    switch(lookahead)    {    case F_EQ: low_lex(); calc7b(); f_eq(2); continue;    case F_NE: low_lex(); calc7b(); f_ne(2); continue;    }    break;    }   }    - static void calc6() + static void calc6(void)   {    calc7();       while(lookahead=='&')    {    low_lex();    calc7();    o_and();    }   }    - static void calc5() + static void calc5(void)   {    calc6();       while(lookahead=='^')    {    low_lex();    calc6();    o_xor();    }   }    - static void calc4() + static void calc4(void)   {    calc5();       while(lookahead=='|')    {    low_lex();    calc5();    o_or();    }   }    - static void calc3() + static void calc3(void)   {    calc4();       while(lookahead==F_LAND)    {    low_lex();    check_destructed(sp-1);    if(IS_ZERO(sp-1))    {    calc4();    pop_stack();    }else{    pop_stack();    calc4();    }    }   }    - static void calc2() + static void calc2(void)   {    calc3();       while(lookahead==F_LOR)    {    low_lex();    check_destructed(sp-1);    if(!IS_ZERO(sp-1))    {    calc3();    pop_stack();    }else{    pop_stack();    calc3();    }    }   }    - static void calc1() + static void calc1(void)   {    calc2();       if(lookahead=='?')    {    low_lex();    calc1();    if(lookahead!=':')    error("Colon expected.\n");    low_lex();    calc1();       check_destructed(sp-3);    assign_svalue(sp-3,IS_ZERO(sp-3)?sp-1:sp-2);    pop_n_elems(2);    }      }    - static int calc() + static int calc(void)   {    JMP_BUF recovery;    int ret;       ret=0;    if (SETJMP(recovery))    {    if(throw_value.type == T_ARRAY && throw_value.u.array->size)    {    union anything *a;
pike.git/src/lex.c:2098:    check_destructed(sp-1);    ret=!IS_ZERO(sp-1);    pop_stack();    }    UNSETJMP(recovery);       return ret;   }      /*** Magic defines ***/ - void insert_current_line() + void insert_current_line(void)   {    char buf[20];    sprintf(buf," %ld ",(long)current_line);    UNGETSTR(buf,strlen(buf));   }    - void insert_current_file_as_string() + void insert_current_file_as_string(void)   {    UNGETSTR("\"",1);    UNGETSTR(current_file->str, current_file->len);    UNGETSTR("\"",1);   }    - void insert_current_time_as_string() + void insert_current_time_as_string(void)   {    time_t tmp;    char *buf;    time(&tmp);    buf=ctime(&tmp);       UNGETSTR("\"",1);    UNGETSTR(buf+11, 8);    UNGETSTR("\"",1);   }    - void insert_current_date_as_string() + void insert_current_date_as_string(void)   {    time_t tmp;    char *buf;    time(&tmp);    buf=ctime(&tmp);       UNGETSTR("\"",1);    UNGETSTR(buf+19, 5);    UNGETSTR(buf+4, 6);    UNGETSTR("\"",1);   }      /*** ***/    - static void start_new() + static void start_new(void)   {    struct pike_predef_s *tmpf;       free_all_defines();       simple_add_define("__PIKE__", "1",0);       for (tmpf=pike_predefs; tmpf; tmpf=tmpf->next)    simple_add_define(tmpf->name, tmpf->value,0);   
pike.git/src/lex.c:2182:   }      void start_new_string(char *s,INT32 len,struct pike_string *name)   {    start_new();    copy_shared_string(current_file,name);    link_inputstate(prot_memory_inputstate(s,len));    UNGETSTR("\n",1);   }    - void end_new_file() + void end_new_file(void)   {    if(current_file)    {    free_string(current_file);    current_file=0;    }       free_inputstate(istate);    istate=NULL;    free_all_defines();