/**
socket_poll_alloc : int -> 'poll
<doc>Allocate memory to perform polling on a given number of sockets</doc>
**/
static value socket_poll_alloc( value nsocks ) {
polldata *p;
int i;
val_check(nsocks,int);
p = (polldata*)alloc(sizeof(polldata));
p->max = val_int(nsocks);
if( p->max < 0 || p->max > 1000000 )
neko_error();
# ifdef NEKO_WINDOWS
{
p->fdr = (fd_set*)alloc_private(FDSIZE(p->max));
p->fdw = (fd_set*)alloc_private(FDSIZE(p->max));
p->outr = (fd_set*)alloc_private(FDSIZE(p->max));
p->outw = (fd_set*)alloc_private(FDSIZE(p->max));
p->fdr->fd_count = 0;
p->fdw->fd_count = 0;
}
# else
p->fds = (struct pollfd*)alloc_private(sizeof(struct pollfd) * p->max);
p->rcount = 0;
p->wcount = 0;
# endif
p->ridx = alloc_array(p->max+1);
p->widx = alloc_array(p->max+1);
for(i=0;i<=p->max;i++) {
val_array_ptr(p->ridx)[i] = alloc_int(-1);
val_array_ptr(p->widx)[i] = alloc_int(-1);
}
return alloc_abstract(k_poll, p);
}
/**
request : 'db -> sql:string -> 'result
<doc>Executes the SQL request and returns its result</doc>
**/
static value request( value v, value sql ) {
database *db;
result *r;
const char *tl;
int i,j;
val_check_kind(v,k_db);
val_check(sql,string);
db = val_db(v);
r = (result*)alloc(sizeof(result));
r->db = db;
if( sqlite3_prepare(db->db,val_string(sql),val_strlen(sql),&r->r,&tl) != SQLITE_OK ) {
buffer b = alloc_buffer("Sqlite error in ");
val_buffer(b,sql);
buffer_append(b," : ");
buffer_append(b,sqlite3_errmsg(db->db));
val_throw(buffer_to_string(b));
}
if( *tl ) {
sqlite3_finalize(r->r);
val_throw(alloc_string("Cannot execute several SQL requests at the same time"));
}
r->ncols = sqlite3_column_count(r->r);
r->names = (field*)alloc_private(sizeof(field)*r->ncols);
r->bools = (int*)alloc_private(sizeof(int)*r->ncols);
r->first = 1;
r->done = 0;
for(i=0;i<r->ncols;i++) {
field id = val_id(sqlite3_column_name(r->r,i));
const char *dtype = sqlite3_column_decltype(r->r,i);
for(j=0;j<i;j++)
if( r->names[j] == id ) {
if( strcmp(sqlite3_column_name(r->r,i),sqlite3_column_name(r->r,j)) == 0 ) {
buffer b = alloc_buffer("Error, same field is two times in the request ");
val_buffer(b,sql);
sqlite3_finalize(r->r);
val_throw(buffer_to_string(b));
} else {
buffer b = alloc_buffer("Error, same field ids for : ");
buffer_append(b,sqlite3_column_name(r->r,i));
buffer_append(b," and ");
buffer_append(b,sqlite3_column_name(r->r,j));
buffer_append_char(b,'.');
sqlite3_finalize(r->r);
val_throw(buffer_to_string(b));
}
}
r->names[i] = id;
r->bools[i] = dtype?(strcmp(dtype,"BOOL") == 0):0;
}
// changes in an update/delete
if( db->last != NULL )
finalize_result(val_result(db->last),0);
db->last = alloc_abstract(k_result,r);
return db->last;
}
/*
* Attempt to interpret ASR metadata from a block device. This function
* returns either NULL (not an ASR) or a pointer to a descriptor struct.
* Note that the struct should be fully converted to the correct endianness
* by the time this function returns.
*
* WARNING: If you take disks out of an ASR HostRAID array and plug them in
* to a normal SCSI controller, the array will still show up! Even if you
* scribble over the disks! I assume that the a320raid binary driver only
* does its HostRAID magic if your controller is in RAID mode... but dmraid
* lacks this sort of visibility as to where its block devices come from.
* This is EXTREMELY DANGEROUS if you aren't careful!
*/
static void *
read_metadata_areas(struct lib_context *lc, struct dev_info *di,
size_t * sz, uint64_t * offset, union read_info *info)
{
size_t size = ASR_DISK_BLOCK_SIZE;
uint64_t asr_sboffset = ASR_CONFIGOFFSET;
struct asr *asr;
struct asr_raid_configline *cl;
/*
* Read the ASR reserved block on each disk. This is the very
* last sector of the disk, and we're really only interested in
* the two magic numbers, the version, and the pointer to the
* RAID table. Everything else appears to be unused in v8.
*/
if (!(asr = alloc_private(lc, handler, sizeof(*asr))))
goto bad0;
if (!(asr->rt = alloc_private(lc, handler, sizeof(*asr->rt))))
goto bad1;
if (!read_file(lc, handler, di->path, &asr->rb, size, asr_sboffset))
goto bad2;
/*
* Convert metadata and read in
*/
to_cpu(asr, ASR_BLOCK);
/* Check Signature and read optional extended metadata. */
if (!is_asr(lc, di, asr) || !read_extended(lc, di, asr))
goto bad2;
/*
* Now that we made sure that we have all the metadata, we exit.
*/
cl = this_disk(asr);
if (cl->raidstate == LSU_COMPONENT_STATE_FAILED)
goto bad2;
goto out;
bad2:
dbg_free(asr->rt);
bad1:
asr->rt = NULL;
dbg_free(asr);
bad0:
asr = NULL;
out:
return asr;
}
/**
serialize : any -> string
<doc>Serialize any value recursively</doc>
**/
static value serialize( value o ) {
sbuffer b;
value v;
char *s;
strlist *l;
b.olds = NULL;
b.refs = NULL;
b.nrefs = 0;
b.cur = (unsigned char*)alloc_private(BUF_SIZE);
b.size = BUF_SIZE;
b.pos = 0;
b.totlen = 0;
b.nrec = 0;
serialize_rec(&b,o);
v = alloc_empty_string(b.pos + b.totlen);
s = (char*)val_string(v);
s += b.totlen;
l = b.olds;
memcpy(s,b.cur,b.pos);
while( l != NULL ) {
s -= l->slen;
memcpy(s,l->str,l->slen);
l = l->next;
}
return v;
}
static int das08_cs_attach(struct comedi_device *dev,
struct comedi_devconfig *it)
{
int ret;
unsigned long iobase;
struct pcmcia_device *link = cur_dev; /* XXX hack */
ret = alloc_private(dev, sizeof(struct das08_private_struct));
if (ret < 0)
return ret;
printk("comedi%d: das08_cs: ", dev->minor);
/* deal with a pci board */
if (thisboard->bustype == pcmcia) {
if (link == NULL) {
printk(" no pcmcia cards found\n");
return -EIO;
}
iobase = link->io.BasePort1;
} else {
printk(" bug! board does not have PCMCIA bustype\n");
return -EINVAL;
}
printk("\n");
return das08_common_attach(dev, iobase);
}
static int labpc_attach(struct comedi_device *dev, struct comedi_devconfig *it)
{
unsigned long iobase = 0;
unsigned int irq = 0;
struct pcmcia_device *link;
/* allocate and initialize dev->private */
if (alloc_private(dev, sizeof(struct labpc_private)) < 0)
return -ENOMEM;
/* get base address, irq etc. based on bustype */
switch (thisboard->bustype) {
case pcmcia_bustype:
link = pcmcia_cur_dev; /* XXX hack */
if (!link)
return -EIO;
iobase = link->io.BasePort1;
irq = link->irq.AssignedIRQ;
break;
default:
printk("bug! couldn't determine board type\n");
return -EINVAL;
break;
}
return labpc_common_attach(dev, iobase, irq, 0);
}
static int labpc_attach(struct comedi_device *dev, struct comedi_devconfig *it)
{
unsigned long iobase = 0;
unsigned int irq = 0;
struct pcmcia_device *link;
/* allocate and initialize dev->private */
if (alloc_private(dev, sizeof(struct labpc_private)) < 0)
return -ENOMEM;
/* get base address, irq etc. based on bustype */
switch (thisboard->bustype) {
case pcmcia_bustype:
link = pcmcia_cur_dev; /* XXX hack */
if (!link)
return -EIO;
iobase = link->resource[0]->start;
irq = link->irq;
break;
default:
;
return -EINVAL;
break;
}
return labpc_common_attach(dev, iobase, irq, 0);
}
static int labpc_attach(struct comedi_device *dev, struct comedi_devconfig *it)
{
unsigned long iobase = 0;
unsigned int irq = 0;
struct pcmcia_device *link;
if (alloc_private(dev, sizeof(struct labpc_private)) < 0)
return -ENOMEM;
switch (thisboard->bustype) {
case pcmcia_bustype:
link = pcmcia_cur_dev;
if (!link)
return -EIO;
iobase = link->resource[0]->start;
irq = link->irq;
break;
default:
pr_err("bug! couldn't determine board type\n");
return -EINVAL;
break;
}
return labpc_common_attach(dev, iobase, irq, 0);
}
buffer api_alloc_buffer_len(int inLen)
{
char *s=alloc_private(inLen+1);
memset(s,' ',inLen);
s[inLen] = 0;
buffer b = alloc_buffer(s);
return b;
}
value api_alloc_wstring_len(const wchar_t *inStr,int inLen)
{
char *result = alloc_private(inLen+1);
for(int i=0;i<inLen;i++)
result[i] = inStr[i];
result[inLen] = 0;
return api_alloc_string_len(result,inLen);
}
char * api_val_dup_string(value inVal)
{
int len = api_val_strlen(inVal);
const char *ptr = api_val_string(inVal);
char *result = alloc_private(len+1);
memcpy(result,ptr,len);
result[len] = '\0';
return result;
}
const wchar_t * api_val_wstring(value arg1)
{
int len = api_val_strlen(arg1);
unsigned char *ptr = (unsigned char *)api_val_string(arg1);
wchar_t *result = (wchar_t *)alloc_private((len+1)*sizeof(wchar_t));
for(int i=0;i<len;i++)
result[i] = ptr[i];
result[len] = 0;
return result;
}
static void buffer_alloc( sbuffer *b, int size ) {
strlist *str = (strlist*)alloc(sizeof(strlist));
str->str = b->cur;
str->slen = b->pos;
str->next = b->olds;
b->olds = str;
b->totlen += b->pos;
b->pos = 0;
b->size = size;
b->cur = (unsigned char*)alloc_private(size);
}
/**
regexp_new_options : reg:string -> options:string -> 'regexp
<doc>Build a new regexpr with the following options :
<ul>
<li>i : case insensitive matching</li>
<li>s : . match anything including newlines</li>
<li>m : treat the input as a multiline string</li>
<li>u : run in utf8 mode</li>
<li>g : turn off greedy behavior</li>
</ul>
</doc>
**/
static value regexp_new_options( value s, value opt ) {
val_check(s,string);
val_check(opt,string);
{
value v;
const char *error;
int err_offset;
pcre *p;
pcredata *pdata;
char *o = val_string(opt);
int options = 0;
while( *o ) {
switch( *o++ ) {
case 'i':
options |= PCRE_CASELESS;
break;
case 's':
options |= PCRE_DOTALL;
break;
case 'm':
options |= PCRE_MULTILINE;
break;
case 'u':
options |= PCRE_UTF8;
break;
case 'g':
options |= PCRE_UNGREEDY;
break;
default:
neko_error();
break;
}
}
p = pcre_compile(val_string(s),options,&error,&err_offset,NULL);
if( p == NULL ) {
buffer b = alloc_buffer("Regexp compilation error : ");
buffer_append(b,error);
buffer_append(b," in ");
val_buffer(b,s);
bfailure(b);
}
v = alloc_abstract(k_regexp,alloc(sizeof(pcredata)));
pdata = PCRE(v);
pdata->r = p;
pdata->str = val_null;
pdata->nmatchs = 0;
pcre_fullinfo(p,NULL,PCRE_INFO_CAPTURECOUNT,&pdata->nmatchs);
pdata->nmatchs++;
pdata->matchs = (int*)alloc_private(sizeof(int) * 3 * pdata->nmatchs);
val_gc(v,free_regexp);
return v;
}
}
static value alloc_result( connection *c, MYSQL_RES *r ) {
result *res = (result*)alloc(sizeof(result));
value o = alloc_abstract(k_result,res);
int num_fields = mysql_num_fields(r);
int i,j;
MYSQL_FIELD *fields = mysql_fetch_fields(r);
res->r = r;
res->conv_date = c->conv_date;
res->conv_bytes = c->conv_bytes;
res->conv_string = c->conv_string;
res->current = NULL;
res->nfields = num_fields;
res->fields_ids = (field*)alloc_private(sizeof(field)*num_fields);
res->fields_convs = (CONV*)alloc_private(sizeof(CONV)*num_fields);
for(i=0;i<num_fields;i++) {
field id;
if( strchr(fields[i].name,'(') )
id = val_id("???"); // looks like an inner request : prevent hashing + cashing it
else {
id = val_id(fields[i].name);
for(j=0;j<i;j++)
if( res->fields_ids[j] == id ) {
buffer b = alloc_buffer("Error, same field ids for : ");
buffer_append(b,fields[i].name);
buffer_append(b,":");
val_buffer(b,alloc_int(i));
buffer_append(b," and ");
buffer_append(b,fields[j].name);
buffer_append(b,":");
val_buffer(b,alloc_int(j));
buffer_append(b,".");
bfailure(b);
}
}
res->fields_ids[i] = id;
res->fields_convs[i] = convert_type(fields[i].type,fields[i].flags,fields[i].length);
}
val_gc(o,free_result);
return o;
}
static void buffer_append_new( buffer b, const char *s, int len ) {
int size;
stringitem it;
while( b->totlen >= (b->blen << 2) )
b->blen <<= 1;
size = (len < b->blen)?b->blen:len;
it = (stringitem)alloc(sizeof(struct _stringitem));
it->str = alloc_private(size);
memcpy(it->str,s,len);
it->size = size;
it->len = len;
it->next = b->data;
b->data = it;
}
/**
lock_create : void -> 'lock
<doc>Creates a lock which is initially locked</doc>
**/
static value lock_create() {
value vl;
vlock l;
# ifdef NEKO_WINDOWS
l = CreateSemaphore(NULL,0,(1 << 30),NULL);
if( l == NULL )
neko_error();
# else
l = (vlock)alloc_private(sizeof(struct _vlock));
l->counter = 0;
if( pthread_mutex_init(&l->lock,NULL) != 0 || pthread_cond_init(&l->cond,NULL) != 0 )
neko_error();
# endif
vl = alloc_abstract(k_lock,l);
val_gc(vl,free_lock);
return vl;
}
static int fl512_attach(struct comedi_device *dev, struct comedi_devconfig *it)
{
unsigned long iobase;
int ret;
/* pointer to the subdevice: Analog in, Analog out,
(not made ->and Digital IO) */
struct comedi_subdevice *s;
iobase = it->options[0];
printk(KERN_INFO "comedi:%d fl512: 0x%04lx", dev->minor, iobase);
if (!request_region(iobase, FL512_SIZE, "fl512")) {
printk(KERN_WARNING " I/O port conflict\n");
return -EIO;
}
dev->iobase = iobase;
dev->board_name = "fl512";
if (alloc_private(dev, sizeof(struct fl512_private)) < 0)
return -ENOMEM;
#if DEBUG
printk(KERN_DEBUG "malloc ok\n");
#endif
ret = comedi_alloc_subdevices(dev, 2);
if (ret)
return ret;
/*
* this if the definitions of the supdevices, 2 have been defined
*/
/* Analog indput */
s = dev->subdevices + 0;
/* define subdevice as Analog In */
s->type = COMEDI_SUBD_AI;
/* you can read it from userspace */
s->subdev_flags = SDF_READABLE | SDF_GROUND;
/* Number of Analog input channels */
s->n_chan = 16;
/* accept only 12 bits of data */
s->maxdata = 0x0fff;
/* device use one of the ranges */
s->range_table = &range_fl512;
/* function to call when read AD */
s->insn_read = fl512_ai_insn;
printk(KERN_INFO "comedi: fl512: subdevice 0 initialized\n");
/* Analog output */
s = dev->subdevices + 1;
/* define subdevice as Analog OUT */
s->type = COMEDI_SUBD_AO;
/* you can write it from userspace */
s->subdev_flags = SDF_WRITABLE;
/* Number of Analog output channels */
s->n_chan = 2;
/* accept only 12 bits of data */
s->maxdata = 0x0fff;
/* device use one of the ranges */
s->range_table = &range_fl512;
/* function to call when write DA */
s->insn_write = fl512_ao_insn;
/* function to call when reading DA */
s->insn_read = fl512_ao_insn_readback;
printk(KERN_INFO "comedi: fl512: subdevice 1 initialized\n");
return 1;
}
static int nidio_attach(struct comedi_device *dev, struct comedi_devconfig *it)
{
struct comedi_subdevice *s;
int i;
int ret;
int n_subdevices;
unsigned int irq;
printk("comedi%d: nidio:", dev->minor);
if ((ret = alloc_private(dev, sizeof(struct nidio96_private))) < 0)
return ret;
spin_lock_init(&devpriv->mite_channel_lock);
ret = nidio_find_device(dev, it->options[0], it->options[1]);
if (ret < 0)
return ret;
ret = mite_setup(devpriv->mite);
if (ret < 0) {
printk("error setting up mite\n");
return ret;
}
comedi_set_hw_dev(dev, &devpriv->mite->pcidev->dev);
devpriv->di_mite_ring = mite_alloc_ring(devpriv->mite);
if (devpriv->di_mite_ring == NULL)
return -ENOMEM;
dev->board_name = this_board->name;
irq = mite_irq(devpriv->mite);
printk(" %s", dev->board_name);
if (this_board->uses_firmware) {
ret = pci_6534_upload_firmware(dev, it->options);
if (ret < 0)
return ret;
}
if (!this_board->is_diodaq) {
n_subdevices = this_board->n_8255;
} else {
n_subdevices = 1;
}
if ((ret = alloc_subdevices(dev, n_subdevices)) < 0)
return ret;
if (!this_board->is_diodaq) {
for (i = 0; i < this_board->n_8255; i++) {
subdev_8255_init(dev, dev->subdevices + i,
nidio96_8255_cb,
(unsigned long)(devpriv->mite->
daq_io_addr +
NIDIO_8255_BASE(i)));
}
} else {
printk(" rev=%d",
readb(devpriv->mite->daq_io_addr + Chip_Version));
s = dev->subdevices + 0;
dev->read_subdev = s;
s->type = COMEDI_SUBD_DIO;
s->subdev_flags =
SDF_READABLE | SDF_WRITABLE | SDF_LSAMPL | SDF_PACKED |
SDF_CMD_READ;
s->n_chan = 32;
s->range_table = &range_digital;
s->maxdata = 1;
s->insn_config = &ni_pcidio_insn_config;
s->insn_bits = &ni_pcidio_insn_bits;
s->do_cmd = &ni_pcidio_cmd;
s->do_cmdtest = &ni_pcidio_cmdtest;
s->cancel = &ni_pcidio_cancel;
s->len_chanlist = 32;
s->buf_change = &ni_pcidio_change;
s->async_dma_dir = DMA_BIDIRECTIONAL;
writel(0, devpriv->mite->daq_io_addr + Port_IO(0));
writel(0, devpriv->mite->daq_io_addr + Port_Pin_Directions(0));
writel(0, devpriv->mite->daq_io_addr + Port_Pin_Mask(0));
writeb(0x00,
devpriv->mite->daq_io_addr +
Master_DMA_And_Interrupt_Control);
ret = request_irq(irq, nidio_interrupt, IRQF_SHARED,
"ni_pcidio", dev);
if (ret < 0) {
printk(" irq not available");
}
dev->irq = irq;
}
printk("\n");
return 0;
}
/*
options[0] Board base address
options[1] IRQ
options[2] Input configuration
0 == single-ended
1 == differential
2 == pseudo-differential
options[3] Analog input range configuration
0 == bipolar 5 (-5V -- +5V)
1 == bipolar 2.5V (-2.5V -- +2.5V)
2 == unipolar 5V (0V -- +5V)
options[4] Analog output 0 range configuration
0 == bipolar 5 (-5V -- +5V)
1 == bipolar 2.5V (-2.5V -- +2.5V)
2 == unipolar 5V (0V -- +5V)
options[5] Analog output 1 range configuration
0 == bipolar 5 (-5V -- +5V)
1 == bipolar 2.5V (-2.5V -- +2.5V)
2 == unipolar 5V (0V -- +5V)
*/
static int dt2811_attach(struct comedi_device *dev, struct comedi_devconfig *it)
{
/* int i, irq; */
/* unsigned long irqs; */
/* long flags; */
const struct dt2811_board *board = comedi_board(dev);
int ret;
struct comedi_subdevice *s;
unsigned long iobase;
iobase = it->options[0];
printk(KERN_INFO "comedi%d: dt2811:base=0x%04lx\n", dev->minor, iobase);
if (!request_region(iobase, DT2811_SIZE, driver_name)) {
printk(KERN_ERR "I/O port conflict\n");
return -EIO;
}
dev->iobase = iobase;
dev->board_name = board->name;
#if 0
outb(0, dev->iobase + DT2811_ADCSR);
udelay(100);
i = inb(dev->iobase + DT2811_ADDATLO);
i = inb(dev->iobase + DT2811_ADDATHI);
#endif
#if 0
irq = it->options[1];
if (irq < 0) {
save_flags(flags);
sti();
irqs = probe_irq_on();
outb(DT2811_CLRERROR | DT2811_INTENB,
dev->iobase + DT2811_ADCSR);
outb(0, dev->iobase + DT2811_ADGCR);
udelay(100);
irq = probe_irq_off(irqs);
restore_flags(flags);
/*outb(DT2811_CLRERROR|DT2811_INTENB,
dev->iobase+DT2811_ADCSR);*/
if (inb(dev->iobase + DT2811_ADCSR) & DT2811_ADERROR)
printk(KERN_ERR "error probing irq (bad)\n");
dev->irq = 0;
if (irq > 0) {
i = inb(dev->iobase + DT2811_ADDATLO);
i = inb(dev->iobase + DT2811_ADDATHI);
printk(KERN_INFO "(irq = %d)\n", irq);
ret = request_irq(irq, dt2811_interrupt, 0,
driver_name, dev);
if (ret < 0)
return -EIO;
dev->irq = irq;
} else if (irq == 0) {
printk(KERN_INFO "(no irq)\n");
} else {
printk(KERN_ERR "( multiple irq's -- this is bad! )\n");
}
}
#endif
ret = comedi_alloc_subdevices(dev, 4);
if (ret)
return ret;
ret = alloc_private(dev, sizeof(struct dt2811_private));
if (ret < 0)
return ret;
switch (it->options[2]) {
case 0:
devpriv->adc_mux = adc_singleended;
break;
case 1:
devpriv->adc_mux = adc_diff;
break;
case 2:
devpriv->adc_mux = adc_pseudo_diff;
break;
default:
devpriv->adc_mux = adc_singleended;
break;
}
switch (it->options[4]) {
case 0:
devpriv->dac_range[0] = dac_bipolar_5;
break;
case 1:
devpriv->dac_range[0] = dac_bipolar_2_5;
break;
case 2:
devpriv->dac_range[0] = dac_unipolar_5;
break;
default:
devpriv->dac_range[0] = dac_bipolar_5;
break;
}
switch (it->options[5]) {
case 0:
devpriv->dac_range[1] = dac_bipolar_5;
break;
case 1:
devpriv->dac_range[1] = dac_bipolar_2_5;
break;
case 2:
devpriv->dac_range[1] = dac_unipolar_5;
break;
default:
devpriv->dac_range[1] = dac_bipolar_5;
break;
}
s = &dev->subdevices[0];
/* initialize the ADC subdevice */
s->type = COMEDI_SUBD_AI;
s->subdev_flags = SDF_READABLE | SDF_GROUND;
s->n_chan = devpriv->adc_mux == adc_diff ? 8 : 16;
s->insn_read = dt2811_ai_insn;
s->maxdata = 0xfff;
switch (it->options[3]) {
case 0:
default:
s->range_table = board->bip_5;
break;
case 1:
s->range_table = board->bip_2_5;
break;
case 2:
s->range_table = board->unip_5;
break;
}
s = &dev->subdevices[1];
/* ao subdevice */
s->type = COMEDI_SUBD_AO;
s->subdev_flags = SDF_WRITABLE;
s->n_chan = 2;
s->insn_write = dt2811_ao_insn;
s->insn_read = dt2811_ao_insn_read;
s->maxdata = 0xfff;
s->range_table_list = devpriv->range_type_list;
devpriv->range_type_list[0] = dac_range_types[devpriv->dac_range[0]];
devpriv->range_type_list[1] = dac_range_types[devpriv->dac_range[1]];
s = &dev->subdevices[2];
/* di subdevice */
s->type = COMEDI_SUBD_DI;
s->subdev_flags = SDF_READABLE;
s->n_chan = 8;
s->insn_bits = dt2811_di_insn_bits;
s->maxdata = 1;
s->range_table = &range_digital;
s = &dev->subdevices[3];
/* do subdevice */
s->type = COMEDI_SUBD_DO;
s->subdev_flags = SDF_WRITABLE;
s->n_chan = 8;
s->insn_bits = dt2811_do_insn_bits;
s->maxdata = 1;
s->state = 0;
s->range_table = &range_digital;
return 0;
}
static int dt2815_attach(struct comedi_device *dev, struct comedi_devconfig *it)
{
struct comedi_subdevice *s;
int i;
const struct comedi_lrange *current_range_type, *voltage_range_type;
unsigned long iobase;
iobase = it->options[0];
printk(KERN_INFO "comedi%d: dt2815: 0x%04lx ", dev->minor, iobase);
if (!request_region(iobase, DT2815_SIZE, "dt2815")) {
printk(KERN_WARNING "I/O port conflict\n");
return -EIO;
}
dev->iobase = iobase;
dev->board_name = "dt2815";
if (alloc_subdevices(dev, 1) < 0)
return -ENOMEM;
if (alloc_private(dev, sizeof(struct dt2815_private)) < 0)
return -ENOMEM;
s = dev->subdevices;
/* ao subdevice */
s->type = COMEDI_SUBD_AO;
s->subdev_flags = SDF_WRITABLE;
s->maxdata = 0xfff;
s->n_chan = 8;
s->insn_write = dt2815_ao_insn;
s->insn_read = dt2815_ao_insn_read;
s->range_table_list = devpriv->range_type_list;
current_range_type = (it->options[3])
? &range_dt2815_ao_20_current : &range_dt2815_ao_32_current;
voltage_range_type = (it->options[2])
? &range_bipolar5 : &range_unipolar5;
for (i = 0; i < 8; i++) {
devpriv->range_type_list[i] = (it->options[5 + i])
? current_range_type : voltage_range_type;
}
/* Init the 2815 */
outb(0x00, dev->iobase + DT2815_STATUS);
for (i = 0; i < 100; i++) {
/* This is incredibly slow (approx 20 ms) */
unsigned int status;
udelay(1000);
status = inb(dev->iobase + DT2815_STATUS);
if (status == 4) {
unsigned int program;
program = (it->options[4] & 0x3) << 3 | 0x7;
outb(program, dev->iobase + DT2815_DATA);
printk(KERN_INFO ", program: 0x%x (@t=%d)\n",
program, i);
break;
} else if (status != 0x00) {
printk(KERN_WARNING "dt2815: unexpected status 0x%x "
"(@t=%d)\n", status, i);
if (status & 0x60)
outb(0x00, dev->iobase + DT2815_STATUS);
}
}
return 0;
}
/**
process_run : cmd:string -> args:string array -> 'process
<doc>
Start a process using a command and the specified arguments.
When args is not null, cmd and args will be auto-quoted/escaped.
If no auto-quoting/escaping is desired, you should append necessary
arguments to cmd as if it is inputted to the shell directly, and pass
null as args.
</doc>
**/
static value process_run( value cmd, value vargs ) {
int i, isRaw;
vprocess *p;
val_check(cmd,string);
isRaw = val_is_null(vargs);
if (!isRaw) {
val_check(vargs,array);
}
# ifdef NEKO_WINDOWS
{
SECURITY_ATTRIBUTES sattr;
STARTUPINFO sinf;
HANDLE proc = GetCurrentProcess();
HANDLE oread,eread,iwrite;
// creates commandline
buffer b = alloc_buffer(NULL);
value sargs;
if (isRaw) {
char* cmdexe = getenv("COMSPEC");
if (!cmdexe) cmdexe = "cmd.exe";
buffer_append(b,"\"");
buffer_append(b,cmdexe);
buffer_append(b,"\" /C \"");
buffer_append(b,val_string(cmd));
buffer_append_char(b,'"');
} else {
buffer_append_char(b,'"');
val_buffer(b,cmd);
buffer_append_char(b,'"');
for(i=0;i<val_array_size(vargs);i++) {
value v = val_array_ptr(vargs)[i];
int j,len;
unsigned int bs_count = 0;
unsigned int k;
val_check(v,string);
len = val_strlen(v);
buffer_append(b," \"");
for(j=0;j<len;j++) {
char c = val_string(v)[j];
switch( c ) {
case '"':
// Double backslashes.
for (k=0;k<bs_count*2;k++) {
buffer_append_char(b,'\\');
}
bs_count = 0;
buffer_append(b, "\\\"");
break;
case '\\':
// Don't know if we need to double yet.
bs_count++;
break;
default:
// Normal char
for (k=0;k<bs_count;k++) {
buffer_append_char(b,'\\');
}
bs_count = 0;
buffer_append_char(b,c);
break;
}
}
// Add remaining backslashes, if any.
for (k=0;k<bs_count*2;k++) {
buffer_append_char(b,'\\');
}
buffer_append_char(b,'"');
}
}
sargs = buffer_to_string(b);
p = (vprocess*)alloc_private(sizeof(vprocess));
// startup process
sattr.nLength = sizeof(sattr);
sattr.bInheritHandle = TRUE;
sattr.lpSecurityDescriptor = NULL;
memset(&sinf,0,sizeof(sinf));
sinf.cb = sizeof(sinf);
sinf.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
sinf.wShowWindow = SW_HIDE;
CreatePipe(&oread,&sinf.hStdOutput,&sattr,0);
CreatePipe(&eread,&sinf.hStdError,&sattr,0);
CreatePipe(&sinf.hStdInput,&iwrite,&sattr,0);
DuplicateHandle(proc,oread,proc,&p->oread,0,FALSE,DUPLICATE_SAME_ACCESS);
DuplicateHandle(proc,eread,proc,&p->eread,0,FALSE,DUPLICATE_SAME_ACCESS);
DuplicateHandle(proc,iwrite,proc,&p->iwrite,0,FALSE,DUPLICATE_SAME_ACCESS);
CloseHandle(oread);
CloseHandle(eread);
CloseHandle(iwrite);
if( !CreateProcess(NULL,val_string(sargs),NULL,NULL,TRUE,0,NULL,NULL,&sinf,&p->pinf) )
neko_error();
// close unused pipes
CloseHandle(sinf.hStdOutput);
CloseHandle(sinf.hStdError);
CloseHandle(sinf.hStdInput);
}
# else
char **argv;
if (isRaw) {
argv = (char**)alloc_private(sizeof(char*)*4);
argv[0] = "/bin/sh";
argv[1] = "-c";
argv[2] = val_string(cmd);
argv[3] = NULL;
} else {
argv = (char**)alloc_private(sizeof(char*)*(val_array_size(vargs)+2));
argv[0] = val_string(cmd);
for(i=0;i<val_array_size(vargs);i++) {
value v = val_array_ptr(vargs)[i];
val_check(v,string);
argv[i+1] = val_string(v);
}
argv[i+1] = NULL;
}
int input[2], output[2], error[2];
if( pipe(input) || pipe(output) || pipe(error) )
neko_error();
p = (vprocess*)alloc_private(sizeof(vprocess));
p->pid = fork();
if( p->pid == -1 ) {
do_close(input[0]);
do_close(input[1]);
do_close(output[0]);
do_close(output[1]);
do_close(error[0]);
do_close(error[1]);
neko_error();
}
// child
if( p->pid == 0 ) {
close(input[1]);
close(output[0]);
close(error[0]);
dup2(input[0],0);
dup2(output[1],1);
dup2(error[1],2);
execvp(argv[0],argv);
fprintf(stderr,"Command not found : %s\n",val_string(cmd));
exit(1);
}
// parent
do_close(input[0]);
do_close(output[1]);
do_close(error[1]);
p->iwrite = input[1];
p->oread = output[0];
p->eread = error[0];
# endif
{
value vp = alloc_abstract(k_process,p);
val_gc(vp,free_process);
return vp;
}
}
static void *load_primitive( const char *prim, int nargs, value path, liblist **libs ) {
char *pos = strchr(prim,'@');
int len;
liblist *l;
PRIM0 ptr;
if( pos == NULL )
return NULL;
l = *libs;
*pos = 0;
len = (int)strlen(prim) + 1;
# ifndef NEKO_STANDALONE
while( l != NULL ) {
if( memcmp(l->name,prim,len) == 0 )
break;
l = l->next;
}
# endif
if( l == NULL ) {
void *h;
value pname = pname = neko_select_file(path,prim,".ndll");
#ifdef NEKO_STANDALONE
# ifdef NEKO_WINDOWS
h = (void*)GetModuleHandle(NULL);
# else
h = dlopen(NULL,RTLD_LAZY);
# endif
#else
h = dlopen(val_string(pname),RTLD_LAZY);
#endif
if( h == NULL ) {
buffer b = alloc_buffer("Failed to load library : ");
val_buffer(b,pname);
#ifndef NEKO_WINDOWS
buffer_append(b," (");
buffer_append(b,dlerror());
buffer_append(b,")");
#endif
*pos = '@';
bfailure(b);
}
l = (liblist*)alloc(sizeof(liblist));
l->handle = h;
l->name = alloc_private(len);
memcpy(l->name,prim,len);
l->next = *libs;
*libs = l;
ptr = (PRIM0)dlsym(l->handle,"__neko_entry_point");
if( ptr != NULL )
((PRIM0)ptr())();
}
*pos++ = '@';
{
char buf[100];
if( strlen(pos) > 90 )
return NULL;
if( nargs == VAR_ARGS )
sprintf(buf,"%s__MULT",pos);
else
sprintf(buf,"%s__%d",pos,nargs);
ptr = (PRIM0)dlsym(l->handle,buf);
if( ptr == NULL )
return NULL;
return ptr();
}
}
static int multiq3_attach(struct comedi_device *dev,
struct comedi_devconfig *it)
{
int result = 0;
unsigned long iobase;
unsigned int irq;
struct comedi_subdevice *s;
iobase = it->options[0];
printk(KERN_INFO "comedi%d: multiq3: 0x%04lx ", dev->minor, iobase);
if (!request_region(iobase, MULTIQ3_SIZE, "multiq3")) {
printk(KERN_ERR "comedi%d: I/O port conflict\n", dev->minor);
return -EIO;
}
dev->iobase = iobase;
irq = it->options[1];
if (irq)
printk(KERN_WARNING "comedi%d: irq = %u ignored\n",
dev->minor, irq);
else
printk(KERN_WARNING "comedi%d: no irq\n", dev->minor);
dev->board_name = "multiq3";
result = comedi_alloc_subdevices(dev, 5);
if (result)
return result;
result = alloc_private(dev, sizeof(struct multiq3_private));
if (result < 0)
return result;
s = dev->subdevices + 0;
/* ai subdevice */
s->type = COMEDI_SUBD_AI;
s->subdev_flags = SDF_READABLE | SDF_GROUND;
s->n_chan = 8;
s->insn_read = multiq3_ai_insn_read;
s->maxdata = 0x1fff;
s->range_table = &range_bipolar5;
s = dev->subdevices + 1;
/* ao subdevice */
s->type = COMEDI_SUBD_AO;
s->subdev_flags = SDF_WRITABLE;
s->n_chan = 8;
s->insn_read = multiq3_ao_insn_read;
s->insn_write = multiq3_ao_insn_write;
s->maxdata = 0xfff;
s->range_table = &range_bipolar5;
s = dev->subdevices + 2;
/* di subdevice */
s->type = COMEDI_SUBD_DI;
s->subdev_flags = SDF_READABLE;
s->n_chan = 16;
s->insn_bits = multiq3_di_insn_bits;
s->maxdata = 1;
s->range_table = &range_digital;
s = dev->subdevices + 3;
/* do subdevice */
s->type = COMEDI_SUBD_DO;
s->subdev_flags = SDF_WRITABLE;
s->n_chan = 16;
s->insn_bits = multiq3_do_insn_bits;
s->maxdata = 1;
s->range_table = &range_digital;
s->state = 0;
s = dev->subdevices + 4;
/* encoder (counter) subdevice */
s->type = COMEDI_SUBD_COUNTER;
s->subdev_flags = SDF_READABLE | SDF_LSAMPL;
s->n_chan = it->options[2] * 2;
s->insn_read = multiq3_encoder_insn_read;
s->maxdata = 0xffffff;
s->range_table = &range_unknown;
encoder_reset(dev);
return 0;
}
void * api_alloc_private(int arg1)
{
return alloc_private(arg1);
}
static int i_ADDI_Attach(struct comedi_device *dev, struct comedi_devconfig *it)
{
struct comedi_subdevice *s;
int ret, pages, i, n_subdevices;
unsigned int dw_Dummy;
resource_size_t io_addr[5];
unsigned int irq;
resource_size_t iobase_a, iobase_main, iobase_addon, iobase_reserved;
struct pcilst_struct *card = NULL;
unsigned char pci_bus, pci_slot, pci_func;
int i_Dma = 0;
ret = alloc_private(dev, sizeof(struct addi_private));
if (ret < 0)
return -ENOMEM;
if (!pci_list_builded) {
v_pci_card_list_init(this_board->i_VendorId, 1); /* 1 for displaying the list.. */
pci_list_builded = 1;
}
/* printk("comedi%d: "ADDIDATA_DRIVER_NAME": board=%s",dev->minor,this_board->pc_DriverName); */
if ((this_board->i_Dma) && (it->options[2] == 0)) {
i_Dma = 1;
}
card = ptr_select_and_alloc_pci_card(this_board->i_VendorId,
this_board->i_DeviceId,
it->options[0],
it->options[1], i_Dma);
if (card == NULL)
return -EIO;
devpriv->allocated = 1;
if ((i_pci_card_data(card, &pci_bus, &pci_slot, &pci_func, &io_addr[0],
&irq)) < 0) {
i_pci_card_free(card);
printk(" - Can't get AMCC data!\n");
return -EIO;
}
iobase_a = io_addr[0];
iobase_main = io_addr[1];
iobase_addon = io_addr[2];
iobase_reserved = io_addr[3];
printk("\nBus %d: Slot %d: Funct%d\nBase0: 0x%8llx\nBase1: 0x%8llx\nBase2: 0x%8llx\nBase3: 0x%8llx\n", pci_bus, pci_slot, pci_func, (unsigned long long)io_addr[0], (unsigned long long)io_addr[1], (unsigned long long)io_addr[2], (unsigned long long)io_addr[3]);
if ((this_board->pc_EepromChip == NULL)
|| (strcmp(this_board->pc_EepromChip, ADDIDATA_9054) != 0)) {
/************************************/
/* Test if more that 1 address used */
/************************************/
if (this_board->i_IorangeBase1 != 0) {
dev->iobase = (unsigned long)iobase_main; /* DAQ base address... */
} else {
dev->iobase = (unsigned long)iobase_a; /* DAQ base address... */
}
dev->board_name = this_board->pc_DriverName;
devpriv->amcc = card;
devpriv->iobase = (int) dev->iobase;
devpriv->i_IobaseAmcc = (int) iobase_a; /* AMCC base address... */
devpriv->i_IobaseAddon = (int) iobase_addon; /* ADD ON base address.... */
devpriv->i_IobaseReserved = (int) iobase_reserved;
devpriv->ps_BoardInfo = this_board;
} else {
dev->board_name = this_board->pc_DriverName;
dev->iobase = (unsigned long)io_addr[2];
devpriv->amcc = card;
devpriv->iobase = (int) io_addr[2];
devpriv->ps_BoardInfo = this_board;
devpriv->i_IobaseReserved = (int) io_addr[3];
printk("\nioremap begin");
devpriv->dw_AiBase = ioremap(io_addr[3],
this_board->i_IorangeBase3);
printk("\nioremap end");
}
/* ## */
if (irq > 0) {
if (request_irq(irq, v_ADDI_Interrupt, IRQF_SHARED,
this_board->pc_DriverName, dev) < 0) {
printk(", unable to allocate IRQ %u, DISABLING IT",
irq);
irq = 0; /* Can't use IRQ */
} else {
printk("\nirq=%u", irq);
}
} else {
printk(", IRQ disabled");
}
printk("\nOption %d %d %d\n", it->options[0], it->options[1],
it->options[2]);
dev->irq = irq;
/* Read eepeom and fill addi_board Structure */
if (this_board->i_PCIEeprom) {
printk("\nPCI Eeprom used");
if (!(strcmp(this_board->pc_EepromChip, "S5920"))) {
/* Set 3 wait stait */
if (!(strcmp(this_board->pc_DriverName, "apci035"))) {
outl(0x80808082, devpriv->i_IobaseAmcc + 0x60);
} else {
outl(0x83838383, devpriv->i_IobaseAmcc + 0x60);
}
/* Enable the interrupt for the controler */
dw_Dummy = inl(devpriv->i_IobaseAmcc + 0x38);
outl(dw_Dummy | 0x2000, devpriv->i_IobaseAmcc + 0x38);
printk("\nEnable the interrupt for the controler");
}
printk("\nRead Eeprom");
i_EepromReadMainHeader(io_addr[0], this_board->pc_EepromChip,
dev);
} else {
printk("\nPCI Eeprom unused");
}
if (it->options[2] > 0) {
devpriv->us_UseDma = ADDI_DISABLE;
} else {
devpriv->us_UseDma = ADDI_ENABLE;
}
if (this_board->i_Dma) {
printk("\nDMA used");
if (devpriv->us_UseDma == ADDI_ENABLE) {
/* alloc DMA buffers */
devpriv->b_DmaDoubleBuffer = 0;
for (i = 0; i < 2; i++) {
for (pages = 4; pages >= 0; pages--) {
devpriv->ul_DmaBufferVirtual[i] =
(void *) __get_free_pages(GFP_KERNEL, pages);
if (devpriv->ul_DmaBufferVirtual[i])
break;
}
if (devpriv->ul_DmaBufferVirtual[i]) {
devpriv->ui_DmaBufferPages[i] = pages;
devpriv->ui_DmaBufferSize[i] =
PAGE_SIZE * pages;
devpriv->ui_DmaBufferSamples[i] =
devpriv->
ui_DmaBufferSize[i] >> 1;
devpriv->ul_DmaBufferHw[i] =
virt_to_bus((void *)devpriv->
ul_DmaBufferVirtual[i]);
}
}
static int adl_pci8164_attach(comedi_device * dev, comedi_devconfig * it)
{
struct pci_dev *pcidev;
comedi_subdevice *s;
int bus, slot;
printk("comedi: attempt to attach...\n");
printk("comedi%d: adl_pci8164\n", dev->minor);
dev->board_name = "pci8164";
bus = it->options[0];
slot = it->options[1];
if (alloc_private(dev, sizeof(adl_pci8164_private)) < 0)
return -ENOMEM;
if (alloc_subdevices(dev, 4) < 0)
return -ENOMEM;
for (pcidev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, NULL);
pcidev != NULL;
pcidev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, pcidev)) {
if (pcidev->vendor == PCI_VENDOR_ID_ADLINK &&
pcidev->device == PCI_DEVICE_ID_PCI8164) {
if (bus || slot) {
/* requested particular bus/slot */
if (pcidev->bus->number != bus
|| PCI_SLOT(pcidev->devfn) != slot) {
continue;
}
}
devpriv->pci_dev = pcidev;
if (comedi_pci_enable(pcidev, "adl_pci8164") < 0) {
printk("comedi%d: Failed to enable PCI device and request regions\n", dev->minor);
return -EIO;
}
dev->iobase = pci_resource_start(pcidev, 2);
printk("comedi: base addr %4lx\n", dev->iobase);
s = dev->subdevices + 0;
s->type = COMEDI_SUBD_PROC;
s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
s->n_chan = 4;
s->maxdata = 0xffff;
s->len_chanlist = 4;
//s->range_table = &range_axis;
s->insn_read = adl_pci8164_insn_read_msts;
s->insn_write = adl_pci8164_insn_write_cmd;
s = dev->subdevices + 1;
s->type = COMEDI_SUBD_PROC;
s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
s->n_chan = 4;
s->maxdata = 0xffff;
s->len_chanlist = 4;
//s->range_table = &range_axis;
s->insn_read = adl_pci8164_insn_read_ssts;
s->insn_write = adl_pci8164_insn_write_otp;
s = dev->subdevices + 2;
s->type = COMEDI_SUBD_PROC;
s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
s->n_chan = 4;
s->maxdata = 0xffff;
s->len_chanlist = 4;
//s->range_table = &range_axis;
s->insn_read = adl_pci8164_insn_read_buf0;
s->insn_write = adl_pci8164_insn_write_buf0;
s = dev->subdevices + 3;
s->type = COMEDI_SUBD_PROC;
s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
s->n_chan = 4;
s->maxdata = 0xffff;
s->len_chanlist = 4;
//s->range_table = &range_axis;
s->insn_read = adl_pci8164_insn_read_buf1;
s->insn_write = adl_pci8164_insn_write_buf1;
printk("comedi: attached\n");
return 1;
}
}
printk("comedi%d: no supported board found! (req. bus/slot : %d/%d)\n",
dev->minor, bus, slot);
return -EIO;
}
hx::Object * alloc_raw_string(int length)
{
return Dynamic( String( (HX_CHAR *) alloc_private(length+1), length) ).GetPtr();
}
/**
process_run : cmd:string -> args:string array -> 'process
<doc>
Start a process using a command and the specified arguments.
</doc>
**/
CAMLprim value process_run( value cmd, value vargs ) {
int i;
vprocess *p;
val_check(cmd,string);
val_check(vargs,array);
# ifdef _WIN32
{
SECURITY_ATTRIBUTES sattr;
STARTUPINFO sinf;
HANDLE proc = GetCurrentProcess();
HANDLE oread,eread,iwrite;
// creates commandline
buffer b = alloc_buffer(NULL);
char *sargs;
buffer_append_char(b,'"');
buffer_append_str(b,val_string(cmd));
buffer_append_char(b,'"');
for(i=0;i<val_array_size(vargs);i++) {
value v = val_array_ptr(vargs)[i];
int j,len;
val_check(v,string);
len = val_strlen(v);
buffer_append_str(b," \"");
for(j=0;j<len;j++) {
char c = val_string(v)[j];
switch( c ) {
case '"':
buffer_append_str(b,"\\\"");
break;
case '\\':
buffer_append_str(b,"\\\\");
break;
default:
buffer_append_char(b,c);
break;
}
}
buffer_append_char(b,'"');
}
sargs = buffer_to_string(b);
p = (vprocess*)alloc_private(sizeof(vprocess));
// startup process
sattr.nLength = sizeof(sattr);
sattr.bInheritHandle = TRUE;
sattr.lpSecurityDescriptor = NULL;
memset(&sinf,0,sizeof(sinf));
sinf.cb = sizeof(sinf);
sinf.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
sinf.wShowWindow = SW_HIDE;
CreatePipe(&oread,&sinf.hStdOutput,&sattr,0);
CreatePipe(&eread,&sinf.hStdError,&sattr,0);
CreatePipe(&sinf.hStdInput,&iwrite,&sattr,0);
DuplicateHandle(proc,oread,proc,&p->oread,0,FALSE,DUPLICATE_SAME_ACCESS);
DuplicateHandle(proc,eread,proc,&p->eread,0,FALSE,DUPLICATE_SAME_ACCESS);
DuplicateHandle(proc,iwrite,proc,&p->iwrite,0,FALSE,DUPLICATE_SAME_ACCESS);
CloseHandle(oread);
CloseHandle(eread);
CloseHandle(iwrite);
if( !CreateProcess(NULL,val_string(sargs),NULL,NULL,TRUE,0,NULL,NULL,&sinf,&p->pinf) ) {
CloseHandle(p->eread);
CloseHandle(p->oread);
CloseHandle(p->iwrite);
free(sargs);
neko_error();
}
free(sargs);
// close unused pipes
CloseHandle(sinf.hStdOutput);
CloseHandle(sinf.hStdError);
CloseHandle(sinf.hStdInput);
}
# else
char **argv = (char**)alloc_private(sizeof(char*)*(val_array_size(vargs)+2));
argv[0] = val_string(cmd);
for(i=0;i<val_array_size(vargs);i++) {
value v = val_array_ptr(vargs)[i];
val_check(v,string);
argv[i+1] = val_string(v);
}
argv[i+1] = NULL;
int input[2], output[2], error[2];
if( pipe(input) || pipe(output) || pipe(error) )
neko_error();
p = (vprocess*)alloc_private(sizeof(vprocess));
p->pid = fork();
if( p->pid == -1 ) {
do_close(input[0]);
do_close(input[1]);
do_close(output[0]);
do_close(output[1]);
do_close(error[0]);
do_close(error[1]);
neko_error();
}
// child
if( p->pid == 0 ) {
close(input[1]);
close(output[0]);
close(error[0]);
dup2(input[0],0);
dup2(output[1],1);
dup2(error[1],2);
execvp(val_string(cmd),argv);
fprintf(stderr,"Command not found : %s\n",val_string(cmd));
exit(1);
}
// parent
do_close(input[0]);
do_close(output[1]);
do_close(error[1]);
p->iwrite = input[1];
p->oread = output[0];
p->eread = error[0];
# endif
{
value vp = alloc_abstract(k_process,p);
val_gc(vp,free_process);
return vp;
}
}
/**
process_run_raw : cmd:string -> 'process
<doc>
Start a process using a command. The input string contains
the command as well as the arguments. Shell meta-characters
will not be auto escaped/quoted.
</doc>
**/
CAMLprim value process_run_raw( value cmd ) {
int i;
vprocess *p;
val_check(cmd,string);
char* cmdStr = val_string(cmd);
# ifdef _WIN32
{
SECURITY_ATTRIBUTES sattr;
STARTUPINFO sinf;
HANDLE proc = GetCurrentProcess();
HANDLE oread,eread,iwrite;
// creates commandline
buffer b = alloc_buffer(NULL);
char *sargs;
buffer_append_char(b,'"');
char* cmdexe = getenv("COMSPEC");
if (!cmdexe) cmdexe = "cmd.exe";
buffer_append_str(b,cmdexe);
buffer_append_char(b,'"');
buffer_append_str(b,"/C \"");
buffer_append_str(b,cmdStr);
buffer_append_char(b,'"');
sargs = buffer_to_string(b);
p = (vprocess*)alloc_private(sizeof(vprocess));
// startup process
sattr.nLength = sizeof(sattr);
sattr.bInheritHandle = TRUE;
sattr.lpSecurityDescriptor = NULL;
memset(&sinf,0,sizeof(sinf));
sinf.cb = sizeof(sinf);
sinf.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
sinf.wShowWindow = SW_HIDE;
CreatePipe(&oread,&sinf.hStdOutput,&sattr,0);
CreatePipe(&eread,&sinf.hStdError,&sattr,0);
CreatePipe(&sinf.hStdInput,&iwrite,&sattr,0);
DuplicateHandle(proc,oread,proc,&p->oread,0,FALSE,DUPLICATE_SAME_ACCESS);
DuplicateHandle(proc,eread,proc,&p->eread,0,FALSE,DUPLICATE_SAME_ACCESS);
DuplicateHandle(proc,iwrite,proc,&p->iwrite,0,FALSE,DUPLICATE_SAME_ACCESS);
CloseHandle(oread);
CloseHandle(eread);
CloseHandle(iwrite);
if( !CreateProcess(NULL,val_string(sargs),NULL,NULL,TRUE,0,NULL,NULL,&sinf,&p->pinf) ) {
CloseHandle(p->eread);
CloseHandle(p->oread);
CloseHandle(p->iwrite);
free(sargs);
neko_error();
}
free(sargs);
// close unused pipes
CloseHandle(sinf.hStdOutput);
CloseHandle(sinf.hStdError);
CloseHandle(sinf.hStdInput);
}
# else
char **argv = (char**)alloc_private(sizeof(char*)*4);
argv[0] = cmd = "/bin/sh";
argv[1] = "-c";
argv[2] = cmdStr;
argv[3] = NULL;
int input[2], output[2], error[2];
if( pipe(input) || pipe(output) || pipe(error) )
neko_error();
p = (vprocess*)alloc_private(sizeof(vprocess));
p->pid = fork();
if( p->pid == -1 ) {
do_close(input[0]);
do_close(input[1]);
do_close(output[0]);
do_close(output[1]);
do_close(error[0]);
do_close(error[1]);
neko_error();
}
// child
if( p->pid == 0 ) {
close(input[1]);
close(output[0]);
close(error[0]);
dup2(input[0],0);
dup2(output[1],1);
dup2(error[1],2);
execvp(val_string(cmd),argv);
fprintf(stderr,"Command not found : %s\n",val_string(cmd));
exit(1);
}
// parent
do_close(input[0]);
do_close(output[1]);
do_close(error[1]);
p->iwrite = input[1];
p->oread = output[0];
p->eread = error[0];
# endif
{
value vp = alloc_abstract(k_process,p);
val_gc(vp,free_process);
return vp;
}
}
