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;
}
