static int expr_semantic_check(elcgen *gen, expression *expr) { int r = 1; switch (expr->type) { case XPATH_FUNCTION_CALL: if (expr->target) { int formalparams = 0; int actualparams = 0; expression *fp; expression *ap; for (ap = expr->r.left; ap; ap = ap->r.right) { assert(XPATH_ACTUAL_PARAM == ap->type); actualparams++; } for (fp = expr->target->r.children; fp; fp = fp->next) { if (XSLT_PARAM == fp->type) formalparams++; else break; } if (formalparams != actualparams) return gen_error(gen,"Insufficient arguments to function {%s}%s\n", expr->target->qn.uri,expr->target->qn.localpart); } break; case XSLT_CHOOSE: { expression *xchild; int otherwise = 0; int whencount = 0; for (xchild = expr->r.children; xchild; xchild = xchild->next) { if (otherwise) return gen_error(gen,"choose contains an element after otherwise: %s", expr_names[xchild->type]); if ((XSLT_WHEN != xchild->type) && (XSLT_OTHERWISE != xchild->type) && (XSLT_DSVAR_INSTRUCTION != xchild->type)) return gen_error(gen,"choose element contains invalid child: %s", expr_names[xchild->type]); if (XSLT_WHEN == xchild->type) whencount++; if (XSLT_OTHERWISE == xchild->type) otherwise = 1; } if ((0 == whencount) && !gen->ispattern) return gen_error(gen,"choose must contain at least one when"); break; } } return r; }
void send_request(unsigned request, size_t par_len, void *par) { iscsid_request_t *req; size_t len; ssize_t ret; int req_temp; len = sizeof(iscsid_request_t) + par_len; /* alloc buffer if static one is too small to hold request */ req_temp = len > sizeof(buf); if (req_temp) { req = malloc(len); if (req == NULL) gen_error("Out of memory allocating %zu bytes\n", len); } else req = (iscsid_request_t *)(void *)buf; /* setup request */ req->request = request; req->parameter_length = (uint32_t)par_len; if (par_len) memcpy(req->parameter, par, par_len); /* and send it out */ ret = sendto(sock, req, len, 0, (struct sockaddr *)(void *)&daemon_name, (socklen_t)sizeof(struct sockaddr_un)); if ((size_t)ret != len) { io_error("Sending daemon message"); } if (req_temp) free(req); }
static int parse_avt(elcgen *gen, xmlNodePtr n, const char *attr, expression **expr, int required, expression *pnode) { char *value; char *tmp; assert(pnode->xmlnode == n); if (!xmlHasProp(n,attr)) { *expr = NULL; if (required) return gen_error(gen,"%s element missing %s attribute",n->name,attr); else return 1; } value = xmlGetProp(n,attr); if (gen->ispattern && (!strncmp(value,"#E",2))) { *expr = new_expression(XPATH_DSVAR); (*expr)->str = strdup(value+1); } else { tmp = (char*)malloc(strlen(value)+3); sprintf(tmp,"}%s{",value); *expr = parse_xpath(gen,pnode,tmp); free(tmp); } free(value); return (NULL != *expr); }
static int expr_resolve_ref(elcgen *gen, expression *expr) { if (XPATH_VAR_REF == expr->type) { expr->target = lookup_var_ref(expr,expr->qn); if (NULL == expr->target) { if (strcmp(expr->qn.uri,"")) return gen_error(gen,"variable {%s}%s not found",expr->qn.uri,expr->qn.localpart); else return gen_error(gen,"variable %s not found",expr->qn.localpart); } } else if (XPATH_FUNCTION_CALL == expr->type) { expr->target = lookup_function(gen,expr->qn); /* failed lookup is ok, might be to built-in function or web service */ } return 1; }
int inquiry(int argc, char **argv) { iscsi_iocommand_parameters_t io; char opt; int pag, rc; (void) memset(&io, 0x0, sizeof(io)); if ((io.session_id = get_sessid(argc, argv, FALSE)) == 0) { return 1; } io.lun = cl_get_longlong('l', argc, argv); opt = cl_get_char('d', argc, argv); switch (opt) { case 0: case '0': opt = 0; break; case 'p': case 'P': io.req.cmd[1] = 0x01; opt = 1; break; case 'c': case 'C': io.req.cmd[1] = 0x02; opt = 2; break; default: gen_error("Invalid detail option '%c'\n", opt); } pag = cl_get_int('p', argc, argv); check_extra_args(argc, argv); io.req.cmdlen = 6; io.req.cmd[0] = 0x12; io.req.cmd[2] = (uint8_t) pag; io.req.cmd[4] = 0xff; io.req.datalen = 0xff; if ((rc = do_ioctl(&io, TRUE)) != 0) { return rc; } if (!io.req.datalen_used) { printf("No Data!\n"); return 1; } dump_data("Inquiry Data:", buf, io.req.datalen_used); return 0; }
INT_VECTOR int_vec_div(INT_VECTOR A, INT_VECTOR B, INT_VECTOR result) { int i, m; m = Int_VecLen(A); if(result==NULL) if((result = int_vec_creat(m, UNDEFINED))==NULL) int_vec_error(INT_VEC_MALLOC); if(m!=Int_VecLen(B)) gen_error(GEN_SIZEMISMATCH); #pragma omp parallel for for(i=0; i<m; ++i) result[i] = A[i]/B[i]; return result; }
expression *parse_xpath(elcgen *gen, expression *pnode, const char *str) { X_BUFFER_STATE bufstate; int r; expression *expr; pthread_mutex_lock(&xpath_lock); parse_node = pnode ? pnode->xmlnode : NULL; parse_firstline = parse_node ? parse_node->line : 0; parse_expr = NULL; lex_lineno = 0; bufstate = x_scan_string(str); x_switch_to_buffer(bufstate); r = xparse(); x_delete_buffer(bufstate); #if HAVE_XLEX_DESTROY xlex_destroy(); #endif if (0 != r) { gen_error(gen,"XPath parse error"); pthread_mutex_unlock(&xpath_lock); return NULL; } expr = parse_expr; parse_expr = NULL; pthread_mutex_unlock(&xpath_lock); if (NULL == expr) gen_error(gen,"XPath parse returned NULL expr"); else expr_set_parents(expr,pnode); return expr; }
static int parse_name(elcgen *gen, xmlNodePtr n, expression *expr, int required) { char *name; if (!xmlHasProp(n,"name")) { if (required) return gen_error(gen,"%s element missing name attribute",n->name); else return 1; } name = xmlGetProp(n,"name"); expr->qn = string_to_qname(name,n); expr->ident = nsname_to_ident(expr->qn.uri,expr->qn.localpart); free(name); return 1; }
MATRIX mat_div_dot(MATRIX A, MATRIX B, MATRIX result) { int i, j, m, n, o, p; m = MatCol(A); n = MatRow(A); o = MatCol(B); p = MatRow(B); if(result==NULL) if((result = mat_creat(MatRow(A), MatCol(A), UNDEFINED))==NULL) return mat_error(MAT_MALLOC); if(o==m &&p==n) { #pragma omp parallel for private(j) for(i=0; i<n; ++i) { for(j=0; j<m; ++j) { result[i][j] = A[i][j]/B[i][j]; } } } else if(o==1 && p!=1) { #pragma omp parallel for private(j) for(i=0; i<n; ++i) { for(j=0; j<m; ++j) { result[i][j] = A[i][j]/B[i][0]; } } } else if(p==1 && o!=1) { #pragma omp parallel for private(j) for(i=0; i<n; ++i) { for(j=0; j<m; ++j) { result[i][j] = A[i][j]/B[0][j]; } } } else gen_error(GEN_SIZEMISMATCH); return result; }
iscsid_response_t * get_response(int temp) { ssize_t ret; size_t len; iscsid_response_t *rsp; int *pbuf; pbuf = (int *)(void *)buf; rsp = (iscsid_response_t *)(void *)&pbuf[1]; *pbuf = 0; /* get size of response */ len = sizeof(iscsid_response_t); ret = recv(sock, rsp, len, MSG_PEEK | MSG_WAITALL); if ((size_t)ret != len) io_error("Receiving daemon data"); len += rsp->parameter_length; /* if a temp buffer has been requested, or if the response is too large to fit into the static buffer, alloc a temp buffer. */ temp = temp || (len > (int)(sizeof(buf) - sizeof(int))); if (temp) { if (NULL == (pbuf = (int *) malloc(len + sizeof(int)))) gen_error("Can't allocate response buffer (%zu bytes)", len + sizeof(int)); rsp = (iscsid_response_t *)(void *)&pbuf[1]; *pbuf = 1; } /* get the complete response */ ret = recv(sock, rsp, len, MSG_WAITALL); if ((size_t)ret != len) io_error("Receiving daemon data"); return rsp; }
static int parse_expr_attr(elcgen *gen, xmlNodePtr n, const char *attr, expression **expr, int required, expression *pnode) { char *value; assert(pnode->xmlnode == n); if (!xmlHasProp(n,attr)) { *expr = NULL; if (required) return gen_error(gen,"%s element missing %s attribute",n->name,attr); else return 1; } value = xmlGetProp(n,attr); *expr = parse_xpath(gen,pnode,value); free(value); return (NULL != *expr); }
QT_BEGIN_NAMESPACE e2prom_util_gui::e2prom_util_gui(int width, int height, QWidget *parent) : QDialog(parent) { resize(width, height); setWindowTitle("E2prom Util"); setup_gui(); QApplication::restoreOverrideCursor(); connect(selt_box->select_template_cmbox, SIGNAL(currentIndexChanged(int)), this, SLOT(switch_param_panel())); connect(console_pbtn, SIGNAL(clicked()), this, SLOT(show_console_output())); connect(generate_pbtn, SIGNAL(clicked()), this, SLOT(collect_params())); connect(this, SIGNAL(has_params(QStringList)), this, SLOT(do_generate_eeprom(QStringList))); connect(this, SIGNAL(param_panel_size_changed()), this, SLOT(adjust_console_tedit())); connect(console_pbtn, SIGNAL(clicked()), this, SLOT(adjust_console_tedit())); connect(&gen_eeprom, SIGNAL(readyReadStandardError()), this, SLOT(update_result_err())); connect(&gen_eeprom, SIGNAL(readyReadStandardOutput()), this, SLOT(update_result_out())); connect(&gen_eeprom, SIGNAL(finished(int, QProcess::ExitStatus)), this, SLOT(gen_exit(int, QProcess::ExitStatus))); connect(&gen_eeprom, SIGNAL(error(QProcess::ProcessError)), this, SLOT(gen_error(QProcess::ProcessError))); }
LLVMValueRef gen_expr(compile_t* c, ast_t* ast) { LLVMValueRef ret; bool has_scope = ast_has_scope(ast); if(has_scope) codegen_pushscope(c, ast); switch(ast_id(ast)) { case TK_SEQ: ret = gen_seq(c, ast); break; case TK_FVARREF: case TK_FLETREF: ret = gen_fieldload(c, ast); break; case TK_EMBEDREF: ret = gen_fieldptr(c, ast); break; case TK_PARAMREF: ret = gen_param(c, ast); break; case TK_VAR: case TK_LET: case TK_MATCH_CAPTURE: ret = gen_localdecl(c, ast); break; case TK_VARREF: case TK_LETREF: ret = gen_localload(c, ast); break; case TK_IF: ret = gen_if(c, ast); break; case TK_WHILE: ret = gen_while(c, ast); break; case TK_REPEAT: ret = gen_repeat(c, ast); break; case TK_TRY: case TK_TRY_NO_CHECK: ret = gen_try(c, ast); break; case TK_MATCH: ret = gen_match(c, ast); break; case TK_CALL: ret = gen_call(c, ast); break; case TK_CONSUME: ret = gen_expr(c, ast_childidx(ast, 1)); break; case TK_RECOVER: ret = gen_expr(c, ast_childidx(ast, 1)); break; case TK_BREAK: ret = gen_break(c, ast); break; case TK_CONTINUE: ret = gen_continue(c, ast); break; case TK_RETURN: ret = gen_return(c, ast); break; case TK_ERROR: ret = gen_error(c, ast); break; case TK_IS: ret = gen_is(c, ast); break; case TK_ISNT: ret = gen_isnt(c, ast); break; case TK_ASSIGN: ret = gen_assign(c, ast); break; case TK_THIS: ret = gen_this(c, ast); break; case TK_TRUE: ret = LLVMConstInt(c->i1, 1, false); break; case TK_FALSE: ret = LLVMConstInt(c->i1, 0, false); break; case TK_INT: ret = gen_int(c, ast); break; case TK_FLOAT: ret = gen_float(c, ast); break; case TK_STRING: ret = gen_string(c, ast); break; case TK_TUPLE: ret = gen_tuple(c, ast); break; case TK_FFICALL: ret = gen_ffi(c, ast); break; case TK_ADDRESS: ret = gen_addressof(c, ast); break; case TK_DIGESTOF: ret = gen_digestof(c, ast); break; case TK_DONTCARE: ret = GEN_NOVALUE; break; case TK_COMPILE_INTRINSIC: ast_error(c->opt->check.errors, ast, "unimplemented compile intrinsic"); return NULL; case TK_COMPILE_ERROR: { ast_t* reason_seq = ast_child(ast); ast_t* reason = ast_child(reason_seq); ast_error(c->opt->check.errors, ast, "compile error: %s", ast_name(reason)); return NULL; } default: ast_error(c->opt->check.errors, ast, "not implemented (codegen unknown)"); return NULL; } if(has_scope) codegen_popscope(c); return ret; }
int parse_xslt(elcgen *gen, xmlNodePtr parent, expression *pnode) { xmlNodePtr n; int r = 1; expression **cptr = &pnode->r.children; for (n = parent->children; n && r; n = n->next) { expression *newnode = NULL; if (ignore_node(n)) continue; if (XML_ELEMENT_NODE == n->type) { if (n->ns && !xmlStrcmp(n->ns->href,XSLT_NS)) { if (!xmlStrcmp(n->name,"output")) { newnode = new_xsltnode(n,XSLT_OUTPUT); } else if (!xmlStrcmp(n->name,"strip-space")) { newnode = new_xsltnode(n,XSLT_STRIP_SPACE); } else if (!xmlStrcmp(n->name,"function")) { newnode = new_xsltnode(n,XSLT_FUNCTION); r = r && parse_name(gen,n,newnode,1); } else if (!xmlStrcmp(n->name,"template")) { newnode = new_xsltnode(n,XSLT_TEMPLATE); newnode->orig = xmlGetProp(n,"match"); r = r && parse_expr_attr(gen,n,"match",&newnode->r.left,0,newnode); r = r && parse_name(gen,n,newnode,0); } else if (!xmlStrcmp(n->name,"param")) { newnode = new_xsltnode(n,XSLT_PARAM); r = r && parse_name(gen,n,newnode,1); } else if (!xmlStrcmp(n->name,"when")) { newnode = new_xsltnode(n,XSLT_WHEN); newnode->orig = xmlGetProp(n,"test"); r = r && parse_expr_attr(gen,n,"test",&newnode->r.left,1,newnode); } else if (!xmlStrcmp(n->name,"otherwise")) { newnode = new_xsltnode(n,XSLT_OTHERWISE); } else if (!xmlStrcmp(n->name,"variable")) { newnode = new_xsltnode(n,XSLT_VARIABLE); r = r && parse_expr_attr(gen,n,"select",&newnode->r.left,0,newnode); r = r && parse_name(gen,n,newnode,1); } else if (!xmlStrcmp(n->name,"sequence")) { newnode = new_xsltnode(n,XSLT_SEQUENCE); newnode->orig = xmlGetProp(n,"select"); r = r && parse_expr_attr(gen,n,"select",&newnode->r.left,1,newnode); } else if (!xmlStrcmp(n->name,"value-of")) { newnode = new_xsltnode(n,XSLT_VALUE_OF); r = r && parse_expr_attr(gen,n,"select",&newnode->r.left,0,newnode); } else if (!xmlStrcmp(n->name,"text")) { char *str = xmlNodeListGetString(gen->parse_doc,n->children,1); if (!strncmp(str,"#S",2) && gen->ispattern) { newnode = new_xsltnode(n,XSLT_DSVAR_TEXTINSTR); newnode->str = strdup((char*)str+1); free(str); } else { newnode = new_xsltnode(n,XSLT_TEXT); newnode->str = str; } } else if (!xmlStrcmp(n->name,"for-each")) { newnode = new_xsltnode(n,XSLT_FOR_EACH); newnode->orig = xmlGetProp(n,"select"); r = r && parse_expr_attr(gen,n,"select",&newnode->r.left,1,newnode); } else if (!xmlStrcmp(n->name,"if")) { newnode = new_xsltnode(n,XSLT_IF); newnode->orig = xmlGetProp(n,"test"); r = r && parse_expr_attr(gen,n,"test",&newnode->r.left,1,newnode); } else if (!xmlStrcmp(n->name,"choose")) { newnode = new_xsltnode(n,XSLT_CHOOSE); } else if (!xmlStrcmp(n->name,"element")) { newnode = new_xsltnode(n,XSLT_ELEMENT); newnode->orig = xmlGetProp(n,"name"); r = r && parse_avt(gen,n,"name",&newnode->r.name_avt,1,newnode); r = r && parse_avt(gen,n,"namespace",&newnode->r.namespace_avt,0,newnode); } else if (!xmlStrcmp(n->name,"attribute")) { newnode = new_xsltnode(n,XSLT_ATTRIBUTE); newnode->orig = xmlGetProp(n,"name"); r = r && parse_expr_attr(gen,n,"select",&newnode->r.left,0,newnode); r = r && parse_avt(gen,n,"name",&newnode->r.name_avt,1,newnode); } else if (!xmlStrcmp(n->name,"namespace")) { newnode = new_xsltnode(n,XSLT_NAMESPACE); newnode->orig = xmlGetProp(n,"name"); r = r && parse_expr_attr(gen,n,"select",&newnode->r.left,0,newnode); r = r && parse_avt(gen,n,"name",&newnode->r.name_avt,1,newnode); } else if (!xmlStrcmp(n->name,"apply-templates")) { newnode = new_xsltnode(n,XSLT_APPLY_TEMPLATES); newnode->orig = xmlGetProp(n,"select"); r = r && parse_expr_attr(gen,n,"select",&newnode->r.left,0,newnode); } else if (!strncmp((char*)n->name,"_Y",2) && gen->ispattern) { newnode = new_xsltnode(n,XSLT_DSVAR_LITELEM); /* newnode->str = strdup((char*)n->name+1); */ newnode->str = strdup("Y::"); /* FIXME: hack */ } else { r = gen_error(gen,"Unsupported XSLT instruction: %s",n->name); } } else { newnode = new_xsltnode(n,XSLT_LITERAL_RESULT_ELEMENT); newnode->qn.uri = n->ns ? strdup((char*)n->ns->href) : strdup(""); newnode->qn.prefix = (n->ns && n->ns->prefix) ? strdup((char*)n->ns->prefix) : strdup(""); newnode->qn.localpart = strdup((char*)n->name); r = r && parse_attributes(gen,n,newnode); } } else if (XML_TEXT_NODE == n->type) { if (!strncmp((char*)n->content,"#I",2) && gen->ispattern) { newnode = new_xsltnode(n,XSLT_DSVAR_INSTRUCTION); newnode->str = strdup((char*)n->content+1); } else if (!strncmp((char*)n->content,"#S",2) && gen->ispattern) { newnode = new_xsltnode(n,XSLT_DSVAR_TEXT); newnode->str = strdup((char*)n->content+1); } else { newnode = new_xsltnode(n,XSLT_LITERAL_TEXT_NODE); newnode->str = strdup((char*)n->content); } } if (newnode) { *cptr = newnode; cptr = &newnode->next; if ((XSLT_TEXT != newnode->type) && (XSLT_DSVAR_TEXTINSTR != newnode->type)) { if (!parse_xslt(gen,n,newnode)) return 0; } } } return r; }
int dev_error(const char *dev_name, const char *s) { gen_error("%s %s\n", dev_name, s); return errno; }
void mat_tqli(MATRIX d, MATRIX e, MATRIX z) { int m, l, iter, i, k, n; mtype s, r, p, g, f, dd, c, b; n = MatRow(z); for(i=1; i<n; ++i) e[i-1][0] = e[i][0]; e[n-1][0] = 0.0; for(l=0; l<n; ++l) { iter = 0; do { for(m=l; m<n-1; ++m) { dd = (mtype)(fabs(d[m][0]) + fabs(d[m+1][0])); if(fabs(e[m][0])+dd == dd) break; } if(m!=l) { if(iter++ == 50) gen_error(GEN_NOT_CONVERGED); g = (d[l+1][0] - d[l][0]) / (2.0f * e[l][0]); r = (mtype)sqrt((g * g) + 1.0f); g = d[m][0] - d[l][0] + e[l][0] / (mtype)(g + __mat_sgn(r, g)); s = c = 1.0; p = 0.0; for(i=m-1; i>=l; --i) { f = s*e[i][0]; b = c*e[i][0]; if(fabs(f) >= fabs(g)) { c = g/f; r = (mtype)sqrt((c*c)+1.0f); e[i+1][0] = f*r; c *= (s = 1.0f/r); } else { s = f/g; r = (mtype)sqrt((s*s)+1.0f); e[i+1][0] = g*r; s *= (c = 1.0f/r); } g = d[i+1][0]-p; r = (d[i][0]-g)*s+2.0f*c*b; p = s*r; d[i+1][0] = g+p; g = c*r-b; for(k=0; k<n; ++k) { f = z[k][i+1]; z[k][i+1] = s*z[k][i]+c*f; z[k][i] = c*z[k][i]-s*f; } } d[l][0] = d[l][0]-p; e[l][0] = g; e[m][0] = 0.0; } } while(m != l); } }
LLVMValueRef gen_expr(compile_t* c, ast_t* ast) { LLVMValueRef ret; bool has_scope = ast_has_scope(ast); bool has_source = codegen_hassource(c); if(has_scope) { codegen_pushscope(c); // Dwarf a new lexical scope, if necessary. if(has_source) dwarf_lexicalscope(&c->dwarf, ast); } switch(ast_id(ast)) { case TK_SEQ: ret = gen_seq(c, ast); break; case TK_FVARREF: case TK_FLETREF: ret = gen_fieldload(c, ast); break; case TK_PARAMREF: ret = gen_param(c, ast); break; case TK_VAR: case TK_LET: ret = gen_localdecl(c, ast); break; case TK_VARREF: case TK_LETREF: ret = gen_localload(c, ast); break; case TK_IF: ret = gen_if(c, ast); break; case TK_WHILE: ret = gen_while(c, ast); break; case TK_REPEAT: ret = gen_repeat(c, ast); break; case TK_TRY: case TK_TRY_NO_CHECK: ret = gen_try(c, ast); break; case TK_MATCH: ret = gen_match(c, ast); break; case TK_CALL: ret = gen_call(c, ast); break; case TK_CONSUME: ret = gen_expr(c, ast_childidx(ast, 1)); break; case TK_RECOVER: ret = gen_expr(c, ast_childidx(ast, 1)); break; case TK_BREAK: ret = gen_break(c, ast); break; case TK_CONTINUE: ret = gen_continue(c, ast); break; case TK_RETURN: ret = gen_return(c, ast); break; case TK_ERROR: ret = gen_error(c, ast); break; case TK_IS: ret = gen_is(c, ast); break; case TK_ISNT: ret = gen_isnt(c, ast); break; case TK_ASSIGN: ret = gen_assign(c, ast); break; case TK_THIS: ret = gen_this(c, ast); break; case TK_TRUE: ret = LLVMConstInt(c->i1, 1, false); break; case TK_FALSE: ret = LLVMConstInt(c->i1, 0, false); break; case TK_INT: ret = gen_int(c, ast); break; case TK_FLOAT: ret = gen_float(c, ast); break; case TK_STRING: ret = gen_string(c, ast); break; case TK_TUPLE: ret = gen_tuple(c, ast); break; case TK_FFICALL: ret = gen_ffi(c, ast); break; case TK_AMP: ret = gen_addressof(c, ast); break; case TK_IDENTITY: ret = gen_identity(c, ast); break; case TK_DONTCARE: ret = GEN_NOVALUE; break; case TK_COMPILER_INTRINSIC: ast_error(ast, "unimplemented compiler intrinsic"); LLVMBuildUnreachable(c->builder); ret = GEN_NOVALUE; break; default: ast_error(ast, "not implemented (codegen unknown)"); return NULL; } if(has_scope) { codegen_popscope(c); if(has_source) dwarf_finish(&c->dwarf); } return ret; }
int cap_error(const char *s) { gen_error("error: %s (%d): %s\n", s, errno, strerror(errno)); return errno; }