예제 #1
0
파일: evaluate.cpp 프로젝트: jesyspa/skipp
ski::node eval(ski::node const& n_orig) {
    arg_vector args;
    auto n = n_orig;
    while (true) {
        warn(n_orig);
        while (auto* app = n.get<ski::application>()) {
            args.push_back(n);
            warn("back:", args.back());
            n = app->f;
        }

        bool id = is_identity(n);

        auto result = boost::apply_visitor(do_evaluate(args), n);
        if (!result)
            break;
        if (args.empty())
            n = n_orig.update(*result);
        else if (id)
            n = get_fun(args.back()) = *result;
        else if (result->get<ski::application>())
            n = get_fun(args.back()).update(*result);
        else
            n = get_fun(args.back()).update(ski::application{
                    ski::combinator{'I'},
                    *result});
    }
    while (!args.empty())
        n = ski::application{n, get_arg(extract(args))};
    return n;
}
예제 #2
0
파일: genfun.c 프로젝트: fydot/ponyc
LLVMValueRef genfun_proto(compile_t* c, gentype_t* g, const char *name,
  ast_t* typeargs)
{
  ast_t* fun = get_fun(g, name, typeargs);
  LLVMValueRef func = get_prototype(c, g, name, typeargs, fun);

  // Disable debugloc on calls to methods that have no debug info.
  if(!ast_debug(fun))
    dwarf_location(&c->dwarf, NULL);

  switch(ast_id(fun))
  {
    case TK_NEW:
    case TK_BE:
      if(g->underlying == TK_ACTOR)
      {
        const char* fun_name = genname_fun(g->type_name, name, typeargs);
        const char* be_name = genname_be(fun_name);
        func = LLVMGetNamedFunction(c->module, be_name);
      }
      break;

    default: {}
  }

  ast_free_unattached(fun);
  return func;
}
예제 #3
0
파일: common.c 프로젝트: mbrossard/pkcs11
CK_FUNCTION_LIST  *pkcs11_get_function_list(const char *param)
{
    CK_FUNCTION_LIST  *funcs;
    CK_RV            (*get_fun)();
    void              *d;
    const char        *e = param ? param : getenv("PKCS11_LIBRARY");
    e = e ? e : DEFAULT_PKCSLIB;

    d = dlopen(e, RTLD_LAZY);
    if (d == NULL) {
        fprintf(stdout, "dlopen('%s') failed\n", e);
        return NULL;
    }
    *(void **) (&get_fun) = dlsym(d, "C_GetFunctionList");
    if (get_fun == NULL) {
        fprintf(stdout, "Symbol lookup failed\n");
        return NULL;
    }
    CK_RV rc = get_fun(&funcs);
    if (rc != CKR_OK) {
        show_error(stdout, "C_GetFunctionList", rc);
        funcs = NULL;
    } else if(funcs == NULL) {
        fprintf(stdout, "C_GetFunctionList returned empty value\n");
    }
    return funcs;
}
예제 #4
0
파일: genheader.c 프로젝트: Preetam/ponyc
static void print_method(compile_t* c, printbuf_t* buf, reachable_type_t* t,
  const char* name, ast_t* typeargs)
{
  const char* funname = genname_fun(t->name, name, typeargs);
  LLVMValueRef func = LLVMGetNamedFunction(c->module, funname);

  if(func == NULL)
    return;

  // Get a reified function.
  ast_t* fun = get_fun(t->ast, name, typeargs);

  if(fun == NULL)
    return;

  AST_GET_CHILDREN(fun, cap, id, typeparams, params, rtype, can_error, body,
    docstring);

  // Print the docstring if we have one.
  if(ast_id(docstring) == TK_STRING)
  {
    printbuf(buf,
      "/*\n"
      "%s"
      "*/\n",
      ast_name(docstring)
      );
  }

  // Print the function signature.
  print_type_name(c, buf, rtype);
  printbuf(buf, " %s", funname);

  switch(ast_id(fun))
  {
    case TK_NEW:
    case TK_BE:
    {
      ast_t* def = (ast_t*)ast_data(t->ast);

      if(ast_id(def) == TK_ACTOR)
        printbuf(buf, "__send");

      break;
    }

    default: {}
  }

  printbuf(buf, "(");
  print_type_name(c, buf, t->ast);
  printbuf(buf, " self");

  print_params(c, buf, params);

  printbuf(buf, ");\n\n");
  ast_free_unattached(fun);
}
예제 #5
0
파일: genfun.c 프로젝트: fydot/ponyc
static LLVMValueRef genfun_newbe(compile_t* c, gentype_t* g, const char *name,
  ast_t* typeargs)
{
  ast_t* fun = get_fun(g, name, typeargs);
  LLVMValueRef func = get_prototype(c, g, name, typeargs, fun);

  if(func == NULL)
  {
    ast_free_unattached(fun);
    return NULL;
  }

  codegen_startfun(c, func, ast_debug(fun));
  name_params(c, g->ast, ast_childidx(fun, 3), func);
  genfun_dwarf(c, g, name, typeargs, fun);

  if(!gen_field_init(c, g))
  {
    ast_free_unattached(fun);
    return NULL;
  }

  ast_t* body = ast_childidx(fun, 6);
  LLVMValueRef value = gen_expr(c, body);

  if(value == NULL)
  {
    ast_free_unattached(fun);
    return NULL;
  }

  LLVMBuildRetVoid(c->builder);
  codegen_finishfun(c);

  // Generate the sender.
  LLVMValueRef sender = get_sender(c, g, name, typeargs);
  codegen_startfun(c, sender, false);
  LLVMValueRef this_ptr = LLVMGetParam(sender, 0);

  // Send the arguments in a message to 'this'.
  uint32_t index = genfun_vtable_index(c, g, name, typeargs);
  LLVMTypeRef msg_type_ptr = send_message(c, fun, this_ptr, sender, index);

  genfun_dwarf_return(c, body);

  // Return 'this'.
  LLVMBuildRet(c->builder, this_ptr);
  codegen_finishfun(c);

  // Add the dispatch case.
  add_dispatch_case(c, g, fun, index, func, msg_type_ptr);
  ast_free_unattached(fun);

  return func;
}
예제 #6
0
파일: genfun.c 프로젝트: fydot/ponyc
LLVMTypeRef genfun_sig(compile_t* c, gentype_t* g, const char *name,
  ast_t* typeargs)
{
  // If the function already exists, return its type.
  const char* funname = genname_fun(g->type_name, name, typeargs);
  LLVMValueRef func = LLVMGetNamedFunction(c->module, funname);

  if(func != NULL)
    return LLVMGetElementType(LLVMTypeOf(func));

  ast_t* fun = get_fun(g, name, typeargs);
  LLVMTypeRef type = get_signature(c, g, fun);
  ast_free_unattached(fun);
  return type;
}
예제 #7
0
TEST(AutoTests, BasicTest) {
  auto a = 1 + 2;
  LOG_INFO("type of a: %s", typeid(a).name());
  auto b = add(1, 1.2);
  LOG_INFO("type of b: %s", typeid(b).name());
  auto d = {1, 2};
  LOG_INFO("type of d: %s", typeid(d).name());

  auto my_lambda = [](int x) { return x + 3; };
  LOG_INFO("my_lambda: %d",  my_lambda(5));

  auto my_fun = get_fun(2);
  LOG_INFO("type of my_fun: %s", typeid(my_fun).name());

  LOG_INFO("my_fun: %lf", my_fun(3));
}
예제 #8
0
파일: genfun.c 프로젝트: jonas-l/ponyc
static LLVMValueRef genfun_new(compile_t* c, gentype_t* g, const char *name,
  ast_t* typeargs)
{
  ast_t* fun = get_fun(g, name, typeargs);
  LLVMValueRef func = get_prototype(c, g, name, typeargs, fun);

  if(func == NULL)
  {
    ast_free_unattached(fun);
    return NULL;
  }

  if(LLVMCountBasicBlocks(func) != 0)
  {
    ast_free_unattached(fun);
    return func;
  }

  codegen_startfun(c, func, ast_debug(fun));
  name_params(c, g->ast, ast_childidx(fun, 3), func);
  genfun_dwarf(c, g, name, typeargs, fun);

  if(!gen_field_init(c, g))
  {
    ast_free_unattached(fun);
    return NULL;
  }

  ast_t* body = ast_childidx(fun, 6);
  LLVMValueRef value = gen_expr(c, body);

  if(value == NULL)
  {
    ast_free_unattached(fun);
    return NULL;
  }

  genfun_dwarf_return(c, body);

  // Return 'this'.
  LLVMBuildRet(c->builder, LLVMGetParam(func, 0));
  codegen_finishfun(c);

  ast_free_unattached(fun);
  return func;
}
예제 #9
0
파일: auto.cpp 프로젝트: bsdshell/cpp
int main()
{
    auto a = 1 + 2;
    std::cout << "type of a: " << typeid(a).name() << '\n';
    auto b = add(1, 1.2);
    std::cout << "type of b: " << typeid(b).name() << '\n';
    //auto int c; //compile-time error
    auto d = {1, 2};
    std::cout << "type of d: " << typeid(d).name() << '\n';
 
    auto my_lambda = [](int x) { return x + 3; };
    std::cout << "my_lambda: " << my_lambda(5) << '\n';
 
    auto my_fun = get_fun(2);
    std::cout << "type of my_fun: " << typeid(my_fun).name() << '\n';
    std::cout << "my_fun: " << my_fun(3) << '\n';
}
예제 #10
0
파일: common.c 프로젝트: mbrossard/pkcs11
CK_FUNCTION_LIST  *pkcs11_get_function_list(const char *param)
{
    CK_FUNCTION_LIST  *funcs;
    void              *d;
    const char        *e = param ? param : getenv("PKCS11_LIBRARY");
    e = e ? e : DEFAULT_PKCSLIB;

    d = LoadLibrary(e);
    if (d == NULL) {
        fprintf(stdout, "LoadLibrary Failed (%s)\n", e);
        return NULL;
    }

#ifndef USE_GET_FUNCTION_LIST
    /* Look-up all symbols from dll */
    funcs = (CK_FUNCTION_LIST_PTR) malloc(sizeof(CK_FUNCTION_LIST));
    if(funcs) {
#undef CK_NEED_ARG_LIST
#undef CK_PKCS11_FUNCTION_INFO
#define CK_PKCS11_FUNCTION_INFO(name)                       \
        if((funcs->name = (CK_RV (*)())GetProcAddress(d, #name)) == NULL) { \
            fprintf(stdout, "Error looking up %s\n", #name); \
            free(funcs); \
            return NULL; \
        }
#include "pkcs11f.h"
    }
#else
    /* Look-up C_GetFunctionList and use it to get all functions */
    CK_RV            (*get_fun)();
    get_fun = (CK_RV (*)())GetProcAddress(d, "C_GetFunctionList");
    if (get_fun == NULL) {
        fprintf(stdout, "Symbol lookup failed\n");
        return NULL;
    }
    CK_RV rc = get_fun(&funcs);
    if (rc != CKR_OK) {
        show_error(stdout, "C_GetFunctionList", rc);
        funcs = NULL;
    } else if(funcs == NULL) {
        fprintf(stdout, "C_GetFunctionList returned empty value\n");
    }
#endif
    return funcs;
}
예제 #11
0
파일: genfun.c 프로젝트: fydot/ponyc
static LLVMValueRef genfun_fun(compile_t* c, gentype_t* g, const char *name,
  ast_t* typeargs)
{
  ast_t* fun = get_fun(g, name, typeargs);
  LLVMValueRef func = get_prototype(c, g, name, typeargs, fun);

  if(func == NULL)
  {
    ast_free_unattached(fun);
    return NULL;
  }

  if(LLVMCountBasicBlocks(func) != 0)
  {
    ast_free_unattached(fun);
    return func;
  }

  codegen_startfun(c, func, ast_debug(fun));
  name_params(c, g->ast, ast_childidx(fun, 3), func);
  genfun_dwarf(c, g, name, typeargs, fun);

  ast_t* body = ast_childidx(fun, 6);
  LLVMValueRef value = gen_expr(c, body);

  if(value == NULL)
  {
    ast_free_unattached(fun);
    return NULL;
  } else if(value != GEN_NOVALUE) {
    genfun_dwarf_return(c, body);

    LLVMTypeRef f_type = LLVMGetElementType(LLVMTypeOf(func));
    LLVMTypeRef r_type = LLVMGetReturnType(f_type);

    LLVMValueRef ret = gen_assign_cast(c, r_type, value, ast_type(body));
    LLVMBuildRet(c->builder, ret);
  }

  codegen_finishfun(c);
  ast_free_unattached(fun);

  return func;
}
예제 #12
0
int test_auto1()
{
	auto a = 1 + 2;
	std::cout << "type of a: " << typeid(a).name() << '\n'; // type of a: int
	auto b = add(1, 1.2);
	std::cout << "type of b: " << typeid(b).name() << '\n'; // type of b: double
	auto c = { 1, 2 };
	std::cout << "type of c: " << typeid(c).name() << '\n'; // type of c: class std::initializer_list<int>

	auto my_lambda = [](int x) { return x + 3; };
	std::cout << "my_lambda: " << my_lambda(5) << '\n'; // my_lambda: 8

	auto my_fun = get_fun(2);
	std::cout << "type of my_fun: " << typeid(my_fun).name() << '\n'; // type of my_fun: double (__cdecl*)(double)
	std::cout << "my_fun: " << my_fun(3) << '\n'; // my_fun: 0.14112

	// auto int x; // error as of C++11: "auto" is no longer a storage-class specifier // error C3530: “auto”不能与任何其他类型说明符组合

	return 0;
}
예제 #13
0
파일: ui.c 프로젝트: zcgeng/ics2015
static int cmd_bt(char *args){
    if(args != NULL)
        printf("(there is no need to input any arguments)\n");
    uint32_t tmp = cpu.ebp;
    uint32_t addr = cpu.eip;
    char name[32];
    int i = 0, j;
    while(get_fun(addr, name)){
        name[31] = '\0';
        printf("#%02d  %08x in %s(",i++, addr, name);
        for(j = 2; j < 6; ++j){
            if(tmp + j * 4 > 0 && tmp + j * 4 < 0x8000000)
                printf("%d, ", swaddr_read(tmp + j*4, 4, R_SS));
        }
        if(tmp + j * 4 > 0 && tmp + j * 4 < 0x8000000)
            printf("%d", swaddr_read(tmp + j * 4, 4, R_SS));
        printf(")\n");
        addr = swaddr_read(tmp + 4, 4, R_SS);
        tmp = swaddr_read(tmp, 4, R_SS);
    }
    return 0;
}
예제 #14
0
파일: jmodem_a.c 프로젝트: cpeterso/jmodem
short main (short argc, char *argv[])
{
    unsigned short status=0;            /* TX and RX status                 */
    unsigned short tries;               /* Attempts to send a file          */
    unsigned short cmp_size;            /* Size after compression           */
    unsigned short data_written;        /* Data written to the file         */
    unsigned short data_read;           /* Data read from the file          */
    char *file_name;                    /* filename                         */
    char *function;                     /* Receive, Transmit                */
    char *com_port;                     /* Communications adapter port      */

    file_name = get_inp (argc, argv);   /* Get file name                    */
    if (file_name == NULL )
    {
        disp();                         /* Display usage message            */
        return JM_FNF;
    }
    function  = get_fun (argc, argv);   /* Get function 'R' or 'S'          */
    if (function == NULL)
    {
        disp();                         /* Display usage message            */
        return JM_CMD;
    }
    com_port  = get_prt (argc, argv);   /* Get port '1 to 4 '               */
    if (com_port == NULL)
    {
        disp();                         /* Display usage message            */
        return JM_CMD;
    }
    port = get_port(*com_port);         /* Convert port to an offset        */
/****************************************************************************/
/*                          Allocate buffers                                */
/****************************************************************************/
    in_buffer = allocate_memory(DAT_LEN);  /* Get some memory for input     */
    if (in_buffer == NULL)
        return JM_MEM;                     /* No memory available           */
    out_buffer = allocate_memory(DAT_LEN); /* Get some memory for output    */
    if (out_buffer == NULL)
        return JM_MEM;                     /* No memory available           */
    comp_buffer=allocate_memory(DAT_LEN);  /* Get memory for compression    */
    if (comp_buffer == NULL)
        return JM_MEM;                     /* No memory available           */
    file_buffer=allocate_memory(DAT_LEN);  /* Get memory for file buffer    */
    if (file_buffer == NULL)
        return JM_MEM;                     /* No memory available           */
    int_buffer =allocate_memory(DAT_LEN);  /* Memory for interrupt buffer   */
    if (int_buffer == NULL)
        return JM_MEM;                     /* No memory available           */
/****************************************************************************/

    screen (SCR_SGN,NULL,NULL);            /* Write signon screen           */
    syst.s_len = BLK_SIZ;
    syst.s_byt = 0;
    syst.s_blk = 0;
    syst.s_sta = okay;
    switch(*function)                     /* Functions are TX and RX       */
    {
/****************************************************************************/
/*                          Receive JMODEM file                             */
/****************************************************************************/
    case 'R':
        {
            if (!file_io(CREATE, &handle, &file_name, NULL) )
            {
                buff = (JBUF *) in_buffer;            /* Assign type JBUF   */
                open_chan(port);                      /* Open com channel   */
                screen (SCR_STA,NULL,NULL);           /* Write status block */
                status = rx_sync();                   /* Synchronize        */
                if (!status)
                    screen (SCR_SYR,NULL,NULL);
                data_written = 0xFFFF;
                tries = 10;			    /* Attempts to receive */
                while (    (data_written)             /* Write file okay   */
                        && (!user_abort )             /* No break key      */
                        && (!status     )             /* Recev block okay  */
                        && (tries--)    )             /* 10 retries        */
                {
                    time(&start);                     /* Get starting time */
		    screen (SCR_SYS,&syst,NULL);      /* Show status block */
                    status = recv_blk (               /* Receive data-block*/
                             &syst.s_len,             /* Block length      */
                             in_buffer);              /* Input buffer      */
                    if (status)                       /* If bad            */
                        break;                        /* Abort the WHILE   */
                    if( (!(calc_crc(GET_CRC,          /* Calculate CRC     */
                          syst.s_len,                 /* Amount to check   */
                          in_buffer) ))               /* Receiver buffer   */
		      && ( buff->blk_num ==           /* Check block also  */
                         (unsigned char)
                         (syst.s_blk +1)))            /* Block number      */
                    {
                        syst.s_sta = okay;            /* Text pointer      */
                        tries=10;                     /* Reset count       */
                        syst.s_len -= OVRHD;          /* Subtract overhead */
                        *out_buffer = ACK;            /* Good              */
                        write_chan(1,out_buffer);     /* Send the ACK      */

                        /* If data was compressed                          */
			if ( (buff->blk_typ & COMP) == COMP)
                        {
                             syst.s_len = decode (    /* Decode the data   */
                                      syst.s_len,     /* Data-block length */
				     &buff->blk_dat,  /* Where to start    */
                                     file_buffer);    /* Where to put data */
                        }
                        else
                        /* Data was normal (not compressed, just copy )    */
                        {
                            memcpy (file_buffer,&buff->blk_dat,syst.s_len);
                        }
                        /* Write to the file                                */
                        data_written = file_io( WRITE ,  /* Function        */
                                         &handle,        /* File handle     */
                                         &file_buffer ,  /* Where data is   */
                                         syst.s_len );   /* Amount to write */
                        syst.s_byt += data_written;      /* Total bytes     */
                        syst.s_blk++;                    /* Block number    */
                        time(&finish);                   /* Get end time    */
                        if (finish - start)              /* Check div/0     */
                            syst.s_cps = (short)         /* Calc Block CPS  */
                            (data_written / (finish - start) );

                            /* Check for end-of-file                        */
                        if ( (buff->blk_typ & EOF_) == EOF_)
                        {                       /* This was the end of file */
                            file_io(CLOSE,               /* Function        */
                                   &handle,              /* Open handle     */
                                   &file_name,           /* Name not used   */
                                   NULL);                /* Buffer not used */
                            close_chan(port);            /* Close the port  */
                            status = JM_NRM;             /* Set status      */
                            goto cleanup;                /* exit routine    */
                        }
                    }
                    else
                    {
                        *out_buffer = NAK;              /* Bad block        */
                        syst.s_sta = retry;             /* Char pointer     */
                        write_chan(1,out_buffer);       /* Send the NAK     */
                     }
                }
                close_chan(port);                        /* Aborted         */
                file_io(DELETE,                          /* Function        */
                        &handle,                         /* File handle     */
                        &file_name,                      /* Name            */
                        NULL);                           /* Buffer not used */
                status = JM_ABT;
		break;                                   /* Exit if() {}    */
            }
            else                                       /* Can't create file */
            {
                status = JM_CRE;
                break;                                   /* Exit while() {} */
            }
        break;                                           /* Exit case 'R'   */
        }
/****************************************************************************/
/*                          Send JMODEM file                                */
/****************************************************************************/
    case 'S':   /* Send JMODEM file */
        {
            if (!file_io(OPEN_READ, &handle, &file_name, NULL) )
            {
                buff = (JBUF *)out_buffer;            /* Assign type JBUF   */
                syst.s_byt = 0;                       /* Restore byte count */
                open_chan(port);                      /* Open COM port      */
                data_read = 0xFFFF;                   /* Initialize         */
                screen (SCR_STA,NULL,NULL);           /* Write status block */
                status = tx_sync();                   /* Synchronize        */
                if (!status)
                    screen (SCR_SYT,NULL,NULL);
                while  (  (!user_abort)               /* Ctrl - break       */
                       && (!status) )                 /* sent okay          */
                {
                    time(&start);                     /* Get starting time  */
                    data_read = file_io( READ       , /* Read a record      */
                                       &handle      , /* File pointer       */
                                       &file_buffer , /* Where to put       */
                                      syst.s_len );   /* Amount to read     */
                    if (!data_read)                   /* Past end of file   */
                        break;
                    syst.s_byt += (long) data_read;   /* Running count      */
		    screen (SCR_SYS,&syst,NULL);      /* Show status block  */
                    buff->blk_num = (unsigned char)
                                     ++syst.s_blk;    /* Block number       */
                    if (data_read != syst.s_len)      /* Byte request       */
                        buff->blk_typ = EOF_;         /* Into control-byte  */
                    else
                        buff->blk_typ = NORM;         /* Normal block       */
                    
                    cmp_size = encode (data_read,     /* Encode size        */
                                      file_buffer,    /* Source             */
                                      comp_buffer);   /* Destination        */

                    if ( cmp_size  < data_read  )     /* If compressed      */
                    {
			buff->len = (cmp_size+OVRHD); /* Length of block    */
                        buff->blk_typ |= COMP;        /* Show compressed    */
                        memcpy (&buff->blk_dat,       /* Start of data      */
                                   comp_buffer,       /* Copy from here     */
                                   cmp_size);         /* This much          */
                    }
                    else                              /* Not compressed     */
                    {
			buff->len = (data_read+OVRHD);/* Length of block    */
                        memcpy (&buff->blk_dat,       /* Copy to            */
                                   file_buffer,       /* Copy from          */
                                   data_read);        /* This amount        */
                    }
                    calc_crc(SET_CRC,                 /* Calculate CRC      */
                            buff->len ,               /* Length of block    */
                            out_buffer);              /* Where data is      */
                    status = send_blk(                /* Send the block     */
                             buff->len,               /* Block length       */
                             &syst,                   /* Read block ptr.    */
                             out_buffer);             /* Buffer pointer     */

                    time(&finish);                    /* Get end time       */
                    if (finish - start)               /* Guard div/zero     */
                        syst.s_cps = (short)          /* Calc Block CPS     */
                        (data_read / (finish - start) );
                    if ( buff->blk_typ == EOF_)       /* Last record        */
                        break;
                }
                close_chan(port);                     /* Close the port     */
                if (status)
                    syst.s_sta = abrt;                /* A text pointer     */
                else
                    syst.s_sta = done;                /* A text pointer     */

                file_io(CLOSE, &handle,
                        &file_name, NULL);            /* Close the file     */
                screen (SCR_SYS,&syst,NULL);          /* Show status block  */
            }
            else                                      /* File not found     */
            {
                status = JM_FNF;
            }
        break;  /* End of CASE 'S' */
        }
    }
    cleanup:
    free (in_buffer);                                  /* Free  buffers     */
    free (out_buffer);
    free (comp_buffer);
    free (file_buffer);
    /* Five-second timer to display error messages */
    if (status != JM_NRM)
    {
        time(&finish);
        start = 0;
        finish += 5;
        while ( finish > start )
            time(&start);
    }
    screen (SCR_END,NULL,NULL);                         /* Clear the screen */
    return status;                                      /* Normal exit      */
}
예제 #15
0
파일: expression.c 프로젝트: 38/basiclone
Data* parse_factor( char** p)
{
	Data* ret;
	int curves = 0;
	while(1)
	{
		parse_ws(p);
		if( **p == '(' )
			curves ++;
		else 
			break;
		(*p)++;
		break;
	}
	if( curves )
	{/* (((...(( parsed , expression expected */
		ret = parse_expression(p);
		if( ret->type == TYPE_ERROR )
		{/* error occured*/
			return ret;
		}
		while(curves--)
		{
			/*check ')'*/
			parse_ws(p);
			if( **p != ')' )
			{/*syntax error , curves dose not match*/
				dispose(ret);
				return Raise(SYNTAX);
			}
			(*p)++;
		}
	}
	else
	{/* Constant , Variable , Array and Functions*/
	 /* INKEY$*/
		parse_ws(p);
		if( **p == '"' )
			ret = parse_string(p);
		else if(ISNUMERIC(**p) || **p == '.') 
			ret = parse_numeric(p);
		else if( ISALPHA(**p) || **p == '_' )
		{
			char* id = parse_id(p);
			parse_ws(p);
			if(**p == '(' )
			{
				Subscript *arg;
				Function* f;
				arg = parse_arg(p);
				f = get_fun(id);
				if( f == NULL )
					return Raise(SYNTAX);
				if( arg == NULL )
					return Raise(SYNTAX);
				if( arg->dimension[arg->dimensions-1]->type == TYPE_ERROR )
				{
					ret = Data_new( TYPE_ERROR , 
					                (Storage)arg->dimension[--arg->dimensions]->storage,
					                1);
					free(arg);
				}
				else
				{
					if( f->is_function )
					{/*function call*/
						ret = f->f.foo( arg );
					}
					else
					{/*array*/
						ret = get_arr_element( &f->f.arr , arg );
					}
					dispose_arg(arg);
				}
			}
			else
			{
				/*variable*/
				if( strcmp( id , "INKEY$") == 0 )
				{
					ret = Data_new( TYPE_STRING , (Storage)(char*)malloc(2) , 1 );
					ret->storage.String[0] = inkey();
					ret->storage.String[1] = 0;
				}
				else if( strcmp( id , "__LASTERR$" ) == 0 )
				{
					ret = Data_new( TYPE_STRING , (Storage)(char*)malloc(strlen(err_str[Last_Error.id])) , 1 );
					strcpy( ret->storage.String , err_str[Last_Error.id] );
				}
				else if( strcmp( id, "__LASTERRNO") == 0 )
				{
					ret = Data_new( TYPE_REAL , (Storage)(double)Last_Error.id,1);
				}
				else
					ret = get_var(id);
			}
			free(id);
		}
		else
		{
			ret =Raise(SYNTAX);
		}
	}
	return ret;
}