upm_result_t mma7361_update(const mma7361_context dev) { assert(dev != NULL); float sample; if (dev->aio_x) { if ((sample = (float)mraa_aio_read(dev->aio_x)) < 0.0) { printf("%s: mraa_aio_read(x) failed.\n", __FUNCTION__); return UPM_ERROR_OPERATION_FAILED; } dev->normalized_x = sample / dev->a_res; dev->volts_x = dev->normalized_x * dev->a_ref; dev->accel_x = MAP(dev->volts_x, 0.0, MMA_OUTPUT_AREF, -dev->g_range, dev->g_range); } if (dev->aio_y) { if ((sample = (float)mraa_aio_read(dev->aio_y)) < 0.0) { printf("%s: mraa_aio_read(y) failed.\n", __FUNCTION__); return UPM_ERROR_OPERATION_FAILED; } dev->normalized_y = sample / dev->a_res; dev->volts_y = dev->normalized_y * dev->a_ref; dev->accel_y = MAP(dev->volts_y, 0.0, MMA_OUTPUT_AREF, -dev->g_range, dev->g_range); } if (dev->aio_z) { if ((sample = (float)mraa_aio_read(dev->aio_z)) < 0.0) { printf("%s: mraa_aio_read(z) failed.\n", __FUNCTION__); return UPM_ERROR_OPERATION_FAILED; } dev->normalized_z = sample / dev->a_res; dev->volts_z = dev->normalized_z * dev->a_ref; dev->accel_z = MAP(dev->volts_z, 0.0, MMA_OUTPUT_AREF, -dev->g_range, dev->g_range); } return UPM_SUCCESS; }
struct map * or_map(struct map *mp1, struct map *mp2) { #ifdef MAP_DEBUG if (Mflag) { printf("Oring maps"); print_map(mp1); printf(" and"); print_map(mp2); } #endif if (POSMAP(mp1)) if (POSMAP(mp2)) mp1 = (struct map *)or_bitmap((struct bitmap *) mp1, (struct bitmap *) mp2); else mp1 = NOT_MAP(bic_bitmap(MAP(mp2), (struct bitmap *) mp1)); else if (POSMAP(mp2)) mp1 = NOT_MAP(bic_bitmap(MAP(mp1), (struct bitmap *) mp2)); else mp1 = NOT_MAP(and_bitmap(MAP(mp1), MAP(mp2))); #ifdef MAP_DEBUG if (Mflag) { printf(" ->"); print_map(mp1); printf("\n"); } #endif return mp1; }
static int show_oidmap(struct seq_file *m, void *unused) { struct super_block *sb = m->private; struct reiserfs_sb_info *sb_info = REISERFS_SB(sb); struct reiserfs_super_block *rs = sb_info->s_rs; unsigned int mapsize = le16_to_cpu(rs->s_v1.s_oid_cursize); unsigned long total_used = 0; int i; for (i = 0; i < mapsize; ++i) { __u32 right; right = (i == mapsize - 1) ? MAX_KEY_OBJECTID : MAP(i + 1); seq_printf(m, "%s: [ %x .. %x )\n", (i & 1) ? "free" : "used", MAP(i), right); if (!(i & 1)) { total_used += right - MAP(i); } } #if defined( REISERFS_USE_OIDMAPF ) if (sb_info->oidmap.use_file && (sb_info->oidmap.mapf != NULL)) { loff_t size = file_inode(sb_info->oidmap.mapf)->i_size; total_used += size / sizeof(reiserfs_oidinterval_d_t); } #endif seq_printf(m, "total: \t%i [%i/%i] used: %lu [exact]\n", mapsize, mapsize, le16_to_cpu(rs->s_v1.s_oid_maxsize), total_used); return 0; }
void IllCondDetector::EigenLap(EigenSp const &K) { // Convert Eigen library storage into LAPACK storage N_ = K.cols(); A_ = (double*)calloc(N_ * N_, sizeof(double)); for (int i = 0; i < N_; i++) { for (int j = 0; j < N_; j++) { A_[MAP(i, j, N_)] = K.coeff(i, j); } } // 1-norm computing std::vector<double> tmp; for (int i = 0; i < N_; i++) { double sum = 0; for (int j = 0; j < N_; j++) { sum += A_[MAP(i, j, N_)]; } tmp.push_back(sum); } auto max = std::max_element(tmp.begin(), tmp.end()); Anorm_ = *max; }
int dceslicecompose(DCEslice* s1, DCEslice* s2, DCEslice* result) { int err = NC_NOERR; size_t lastx = 0; DCEslice sr; /* For back compatability so s1 and result can be same object */ #ifdef DEBUG1 slicedump("compose: s1",s1); slicedump("compose: s2",s2); #endif sr.node.sort = CES_SLICE; sr.stride = s1->stride * s2->stride; sr.first = MAP(s1,s2->first); if(sr.first > s1->last) return NC_EINVALCOORDS; lastx = MAP(s1,s2->last); sr.last = XMIN(s1->last,lastx); sr.length = (sr.last + 1) - sr.first; sr.declsize = XMAX(s1->declsize,s2->declsize); /* use max declsize */ /* fill in other fields */ sr.count = (sr.length + (sr.stride - 1))/sr.stride; *result = sr; #ifdef DEBUG1 slicedump("compose: result",result); #endif return err; }
void SortRoutineGraphic::drawBackground() { fill(pDarkGray); rect(fFrame.x, fFrame.y, fFrame.width, fFrame.height); fill(255); stroke(pWhite); strokeWeight(0.5); if (fAnimate) { // do a step in the sorter if (!fSorter->step()) { reset(); } } // Draw the array of values scaled to fit the window for (int idx = 0; idx < nElems; idx++) { double mappedX = (int)MAP(idx, 0, nElems - 1, fFrame.x, fFrame.x + fFrame.width - 1); double mappedY = (int)MAP(fSorter->fElements[idx], 0, MAX_VALUE, fFrame.y + fFrame.height - 1, fFrame.y); point(mappedX, mappedY); if (fShowLines) { line(fFrame.x, fFrame.y + fFrame.height - 1, mappedX, mappedY); } } drawForeground(); }
void NV10EXAComposite(PixmapPtr pix_dst, int srcX, int srcY, int maskX, int maskY, int dstX, int dstY, int width, int height) { ScrnInfoPtr pScrn = xf86Screens[pix_dst->drawable.pScreen->myNum]; NVPtr pNv = NVPTR(pScrn); struct nouveau_channel *chan = pNv->chan; struct nouveau_grobj *celsius = pNv->Nv3D; PicturePtr mask = pNv->pmpict, src = pNv->pspict; PictVector dstq[4] = QUAD(dstX, dstY, width, height), maskq[4] = QUAD(maskX, maskY, width, height), srcq[4] = QUAD(srcX, srcY, width, height); MAP(transform_vertex, src->transform, srcq); if (mask) MAP(transform_vertex, mask->transform, maskq); WAIT_RING (chan, 64); BEGIN_RING(chan, celsius, NV10TCL_VERTEX_BEGIN_END, 1); OUT_RING (chan, NV10TCL_VERTEX_BEGIN_END_QUADS); MAP(emit_vertex, pNv, dstq, srcq, mask ? maskq : NULL); BEGIN_RING(chan, celsius, NV10TCL_VERTEX_BEGIN_END, 1); OUT_RING (chan, NV10TCL_VERTEX_BEGIN_END_STOP); }
void town_adjust(int *dungeon_hgt, int *dungeon_wid) { bool small_town = ((p_ptr->stage < KHAZAD_DUM_TOWN) && !MAP(DUNGEON) && !MAP(FANILLA)); (*dungeon_hgt) /= 3; (*dungeon_wid) /= (small_town ? 6 : 3); }
struct map * add_map(struct map *parm, int node) { struct bitmap *map; int bit; int x, page; #ifdef MAP_DEBUG if (Aflag) { printf("add_map: adding %d to [", node); print_map(parm); printf(" ] "); } #endif bit = NUMBERTOBIT(node); x = NUMBERTOINDEX(node); page = NUMBERTOPAGE(node); bit = 1L << bit;; for (map = MAP(parm); map; map = map->m_next) if (map->m_page == page) break; if (!map) { map = (struct bitmap *)malloc(sizeof *map); if (!map) { #ifdef PRINT_MAP_ERROR printf("No memory!\n"); #endif free_map((struct map *)map); return 0; } map->m_page = page; memset( map->m_data, 0, sizeof map->m_data); if (NEGMAP(parm)) { int i; for (i = 0; i < MDATA; ++i) map->m_data[i] = ~0; } map->m_next = MAP(parm); if (POSMAP(parm)) parm = (struct map *)map; else parm = NOT_MAP(map); } if (POSMAP(parm)) map->m_data[x] |= bit; else map->m_data[x] &= ~bit; #ifdef MAP_DEBUG if (Aflag) { printf(" ->"); print_map(parm); printf("\n"); } #endif return (struct map *)parm; }
int main(int argc, char const **argv) { int fd; mcp3424 j2; mcp3424 j3; unsigned int iteration = 0; int i; int channels[4] = { MCP3424_CHANNEL_1, MCP3424_CHANNEL_2, MCP3424_CHANNEL_3, MCP3424_CHANNEL_4 }; unsigned int res[8]; float v[8]; fd = open("/dev/i2c-1", O_RDWR); if (fd == -1) { printf("error: open: %s\n", strerror(errno)); exit(EXIT_FAILURE); } mcp3424_init(&j2, fd, 0x68, MCP3424_RESOLUTION_14); mcp3424_set_conversion_mode(&j2, MCP3424_CONVERSION_MODE_CONTINUOUS); mcp3424_init(&j3, fd, 0x69, MCP3424_RESOLUTION_14); mcp3424_set_conversion_mode(&j3, MCP3424_CONVERSION_MODE_CONTINUOUS); while (1) { for (i = 0; i < 4; i++) { res[i] = mcp3424_get_raw(&j2, channels[i]); if (j2.err) { printf("error: mcp3424_get_raw: %s\n", j2.errstr); close(fd); exit(EXIT_FAILURE); } v[i] = MAP(res[i], RAW_MIN, RAW_MAX_14, V_MIN, V_MAX); } for (i = 0; i < 4; i++) { res[i + 4] = mcp3424_get_raw(&j3, channels[i]); if (j3.err) { printf("error: mcp3424_get_raw: %s\n", j3.errstr); close(fd); exit(EXIT_FAILURE); } v[i + 4] = MAP(res[i + 4], RAW_MIN, RAW_MAX_14, V_MIN, V_MAX); } printf("iteration: %u\n", iteration++); for (i = 0; i < 8; i++) { printf("res[%d] = %u, v[%d] = %0.2f\n", i, res[i], i, v[i]); } printf("\n"); } close(fd); return EXIT_SUCCESS; }
static driver_id_t driver_id(ripncode_t *r) { struct { const char *name; driver_id_t id; } drivers[] = { #define MAP(_name, _id) { #_name, DRIVER_##_id } MAP(device , DEVICE ), MAP(linux , LINUX ), MAP(aix , AIX ), MAP(bsdi , BSDI ), MAP(netbsd , NETBSD ), MAP(solaris, SOLARIS), MAP(cdrdao , CDRDAO ), MAP(bincue , BINCUE ), MAP(nrg , NRG ), #undef MAP { NULL, -1 } }, *d; if (r->driver == NULL) r->driver = "device"; for (d = drivers; d->name != NULL; d++) if (!strcmp(d->name, r->driver)) return d->id; return DRIVER_UNKNOWN; }
int reiserfs_oidmap_in_proc( char *buffer, char **start, off_t offset, int count, int *eof, void *data ) { struct super_block *sb; struct reiserfs_sb_info *sb_info; struct reiserfs_super_block *rs; int i; unsigned int mapsize; unsigned long total_used; int len = 0; int exact; sb = procinfo_prologue( ( kdev_t ) ( long ) data ); if( sb == NULL ) return -ENOENT; sb_info = &sb->u.reiserfs_sb; rs = sb_info -> s_rs; mapsize = le16_to_cpu( rs -> s_oid_cursize ); total_used = 0; for( i = 0 ; i < mapsize ; ++i ) { __u32 right; right = ( i == mapsize - 1 ) ? MAX_KEY_OBJECTID : MAP( i + 1 ); len += sprintf( &buffer[ len ], "%s: [ %x .. %x )\n", ( i & 1 ) ? "free" : "used", MAP( i ), right ); if( ! ( i & 1 ) ) { total_used += right - MAP( i ); } if( len > PAGE_SIZE - 100 ) { len += sprintf( &buffer[ len ], "... and more\n" ); break; } } #if defined( REISERFS_USE_OIDMAPF ) if( sb_info -> oidmap.use_file && ( sb_info -> oidmap.mapf != NULL ) ) { loff_t size; size = sb_info -> oidmap.mapf -> f_dentry -> d_inode -> i_size; total_used += size / sizeof( reiserfs_oidinterval_d_t ); exact = 1; } else #endif { exact = ( i == mapsize ); } len += sprintf( &buffer[ len ], "total: \t%i [%i/%i] used: %lu [%s]\n", i, mapsize, le16_to_cpu( rs -> s_oid_maxsize ), total_used, exact ? "exact" : "estimation" ); procinfo_epilogue( sb ); return reiserfs_proc_tail( len, buffer, start, offset, count, eof ); }
void drawDataPoints(const int col) { for (int row = 0; row < rowCount; row++){ if (isValid(row, col)) { float value = getFloat(row, col); double x = MAP(data[row].year, yearMin, yearMax, plotX1, plotX2); double y = MAP(value, dataMin, dataMax, plotY2, plotY1); point(x, y); } } }
int RemoveShitNums(int* map, const int n, const int width, const int height){ int num = 0; for(int y = 0; y < height; y++){ for(int x = 0; x < width; x++){ if(MAP(map, x, y) >= n+1){ MAP(map, x, y) = 0; num++; } } } return num; }
static void LIBUSB_CALL dump_iface_list_stream_cb(struct libusb_transfer *transfer) { enum libusb_error err; uhd_iface *iface; assert(transfer != NULL); iface = (uhd_iface *)transfer->user_data; assert(uhd_iface_valid(iface)); /* Clear interface "has transfer submitted" flag */ iface->submitted = false; switch (transfer->status) { case LIBUSB_TRANSFER_COMPLETED: /* Dump the result */ if (!stream_paused) { dump(iface, "STREAM", transfer->buffer, transfer->actual_length); if (stream_feedback) fputc('.', stderr); } /* Resubmit the transfer */ err = libusb_submit_transfer(transfer); if (err != LIBUSB_SUCCESS) LIBUSB_IFACE_FAILURE(iface, "resubmit a transfer"); else { /* Set interface "has transfer submitted" flag */ iface->submitted = true; } break; #define MAP(_name, _desc) \ case LIBUSB_TRANSFER_##_name: \ IFACE_ERROR(iface, _desc); \ break MAP(ERROR, "Interrupt transfer failed"); MAP(TIMED_OUT, "Interrupt transfer timed out"); MAP(STALL, "Interrupt transfer halted (endpoint stalled)"); MAP(NO_DEVICE, "Device was disconnected"); MAP(OVERFLOW, "Interrupt transfer overflowed " "(device sent more data than requested)"); #undef MAP case LIBUSB_TRANSFER_CANCELLED: break; } }
static int __init rockchip_cpu_axi_init(void) { struct device_node *np, *gp, *cp; void __iomem *base; np = of_find_compatible_node(NULL, NULL, "rockchip,cpu_axi_bus"); if (!np) return -ENODEV; #define MAP(base) if (!base) base = of_iomap(cp, 0); if (!base) continue; gp = of_get_child_by_name(np, "qos"); if (gp) { for_each_child_of_node(gp, cp) { u32 priority[2], mode, bandwidth, saturation, extcontrol; base = NULL; #ifdef DEBUG { struct resource r; of_address_to_resource(cp, 0, &r); pr_debug("qos: %s [%x ~ %x]\n", cp->name, r.start, r.end); } #endif if (!of_property_read_u32_array(cp, "rockchip,priority", priority, ARRAY_SIZE(priority))) { MAP(base); CPU_AXI_SET_QOS_PRIORITY(priority[0], priority[1], base); pr_debug("qos: %s priority %x %x\n", cp->name, priority[0], priority[1]); } if (!of_property_read_u32(cp, "rockchip,mode", &mode)) { MAP(base); CPU_AXI_SET_QOS_MODE(mode, base); pr_debug("qos: %s mode %x\n", cp->name, mode); } if (!of_property_read_u32(cp, "rockchip,bandwidth", &bandwidth)) { MAP(base); CPU_AXI_SET_QOS_BANDWIDTH(bandwidth, base); pr_debug("qos: %s bandwidth %x\n", cp->name, bandwidth); } if (!of_property_read_u32(cp, "rockchip,saturation", &saturation)) { MAP(base); CPU_AXI_SET_QOS_SATURATION(saturation, base); pr_debug("qos: %s saturation %x\n", cp->name, saturation); } if (!of_property_read_u32(cp, "rockchip,extcontrol", &extcontrol)) { MAP(base); CPU_AXI_SET_QOS_EXTCONTROL(extcontrol, base); pr_debug("qos: %s extcontrol %x\n", cp->name, extcontrol); } if (base) iounmap(base); } };
template <typename Iter> void serialize_str(const std::string& s, Iter oi) { *oi++ = '"'; for (std::string::const_iterator i = s.begin(); i != s.end(); ++i) { switch (*i) { #define MAP(val, sym) case val: copy(sym, oi); break MAP('"', "\\\""); MAP('\\', "\\\\"); MAP('/', "\\/"); MAP('\b', "\\b"); MAP('\f', "\\f"); MAP('\n', "\\n"); MAP('\r', "\\r"); MAP('\t', "\\t"); #undef MAP default: if (static_cast<unsigned char>(*i) < 0x20 || *i == 0x7f) { char buf[7]; SNPRINTF(buf, sizeof(buf), "\\u%04x", *i & 0xff); copy(buf, buf + 6, oi); } else { *oi++ = *i; } break; } } *oi++ = '"'; }
struct map * copy_map(struct map *parm) { struct bitmap *result, **mpp, *map; #ifdef MAP_DEBUG if (Mflag) { printf("copymap:"); print_map(parm); printf("\n"); } #endif map = MAP(parm); for (mpp = &result; (*mpp = 0), map; map = map->m_next) { *mpp = (struct bitmap *)malloc(sizeof **mpp); if (!*mpp) { #ifdef MAP_DEBUG if (Mflag) printf("copy_map: out of memory\n"); #endif free_map((struct map *)result); result = 0; break; } **mpp = *map; mpp = &(*mpp)->m_next; } if (NEGMAP(parm)) return NOT_MAP(result); else return (struct map *)result; }
/****************************************************************************** Function: DrawMapRect() Action: Draws a portion of the map Params: rect, in LOG (screen) coords. Returns: Comments: Must convert to and from DEV (map) coords. The map contains the mapping mode. ******************************************************************************/ void CWorldMap::DrawMapRect( CDC *pDC, CRect *prect ) { // CDC dcMem; // CBitmap *pbmOld; // BITMAP bm; MAP_ELEMENT *pMap; CRect rDev; CRect rLog; INT nX, nY; LogRectToDevRect( &rDev, prect ); // DevRectToLargestLogRect( &rLog, &rDev ); for( nY = rDev.bottom; nY <= rDev.top; nY++ ) { for( nX = rDev.left; nX <= rDev.right; nX++ ) { rLog = GetLogRectFromMap( nX, nY ); pMap = MAP( nX, nY ); m_pBackImgList->Draw( pDC, pMap->nBackground, CPoint( rLog.left, rLog.top ), ILD_NORMAL ); } } }
static const struct port_map_elem * rule_get (const struct tf *tf, uint32_t port) { const struct port_map *m = MAP (tf); struct port_map_elem tmp = {port}; return bsearch (&tmp, m->elems, m->n, sizeof tmp, map_cmp); }
int RemoveShit(int* map, const int shitNumber, const int shitSize, const int width, const int height){ int num = 0; for(int y = 0; y < height; y++){ for(int x = 0; x < width; x++){ if(MAP(map, x, y) == shitNumber+1){ MAP(map, x, y) = 0; num++; if(shitSize == num){ return num; } } } } return 0; }
/* Return a string representation of a VAEntrypoint */ const char *stringOfVAEntrypoint(VAEntrypoint entrypoint) { switch (entrypoint) { #define MAP(entrypoint) \ STRCASEP(VAEntrypoint, entrypoint) MAP(VLD); MAP(IZZ); MAP(IDCT); MAP(MoComp); MAP(Deblocking); #undef MAP default: break; } return "<unknown>"; }
void drawVolumeLabels() { char numbuff[256]; fill(0); textSize(10); textAlign(TX_RIGHT, TX_CENTER); stroke((uint8_t)128); strokeWeight(1); for (float v = dataMin; v <= dataMax; v += volumeIntervalMinor) { if (int(v) % volumeIntervalMinor == 0) { float y = MAP(v, dataMin, dataMax, plotY2, plotY1); if (int(v) % volumeInterval == 0) { if (v == dataMin) { textAlign(TX_RIGHT); } else if (v == dataMax) { textAlign(TX_RIGHT, TX_TOP); } else { textAlign(TX_RIGHT, TX_CENTER); } sprintf_s(numbuff, "%d", (int)floor(v)); text(numbuff, plotX1 - 10, y); line(plotX1 - 4, y, plotX1, y); // draw a major tick } line(plotX1 - 2, y, plotX1, y); // draw a minor tick } } }
void variant_file::output_as_plink(const parameters ¶ms) { // Output as PLINK formatted PED/MAP files. if (meta_data.has_genotypes == false) LOG.error("Require Genotypes in VCF file in order to output as PLINK."); LOG.printLOG("Writing PLINK PED and MAP files ... \n"); string ped_file = params.output_prefix + ".ped"; string map_file = params.output_prefix + ".map"; int fd = -1; vector<ofstream *> tmp_files(meta_data.N_indv); vector<string> tmp_filenames(meta_data.N_indv); for (unsigned int ui=0; ui<meta_data.N_indv; ui++) { if (include_indv[ui] == false) continue; string new_tmp = params.temp_dir+"/vcftools.XXXXXX"; char tmpname[new_tmp.size()]; strcpy(tmpname, new_tmp.c_str()); fd = mkstemp(tmpname); if (fd == -1) LOG.error(" Could not open temporary file.\n", 12); ::close(fd); ofstream *tmp_file = new ofstream(tmpname); if (!tmp_file->good()) LOG.error("\n\nCould not open temporary file.\n\n" "Most likely this is because the system is not allowing me to open enough temporary files.\n" "Try using ulimit -n <int> to increase the number of allowed open files.\n" "Alternatively, try the --plink-tped command.", 12); (*tmp_file) << meta_data.indv[ui] << "\t" << meta_data.indv[ui] << "\t" << 0 << "\t" << 0 << "\t" << 0 << "\t" << 0; tmp_files[ui] = tmp_file; tmp_filenames[ui] = tmpname; } ofstream MAP(map_file.c_str()); if (!MAP.is_open()) LOG.error("Could not open output file: " + map_file, 12); int POS; string ID, CHROM, CHROM2; map<string, string> CHROM_to_PLINK; if (params.chrom_map_file != "") { ifstream chrom_map(params.chrom_map_file.c_str()); if (!chrom_map.is_open()) LOG.error("Could not open chromosome mapping file: " + params.chrom_map_file); string chr, plink; unsigned int N_chrom_entries=0; while (!chrom_map.eof()) { chrom_map >> chr >> plink; CHROM_to_PLINK[chr] = plink; N_chrom_entries++; } chrom_map.close(); LOG.printLOG("\tRead " + output_log::int2str(N_chrom_entries) + " chromosome mapping file entries.\n"); }
//糞(ズク)をマップからとりのぞく関数 void RemoveAllShit(int* map, const int width, const int height){ for(int y = 0; y < height; y++){ for(int x = 0; x < width; x++){ MAP(map, x, y) = 0; } } }
int count_map(struct map *parm) { int nf; struct bitmap *map; int i, j; nf = 0; for (map = MAP(parm); map; map = map->m_next) { for (i = 0; i < MDATA; ++i) { if (!map->m_data[i]) ; else if (!~map->m_data[i]) nf += (1 << LSHIFT); else for (j = 0; j < (1L << LSHIFT); ++j) if (map->m_data[i] & (1L << j)) ++nf; } } if (NEGMAP(parm)) nf = ~nf; /* note 1's complement */ #ifdef MAP_DEBUG if (Mflag) { printf("countmap:"); print_map(parm); printf(" -> %d\n", nf); } #endif return nf; }
static obj_ptr _map_delete(obj_ptr arg1, obj_ptr arg2, obj_ptr env) { if (NMAPP(arg1)) return MKERROR(MKSTRING("Expected a map in map-delete"), arg1); return MKBOOL(map_delete(&MAP(arg1), arg2)); }
static obj_ptr _map_size(obj_ptr arg, obj_ptr env) { if (NMAPP(arg)) return MKERROR(MKSTRING("Expected a map in map-clear"), arg); return MKINT(map_size(&MAP(arg))); }
static obj_ptr _map_find(obj_ptr args, obj_ptr env) { int ct = _length(args); obj_ptr map, key, res; if (ct < 2 || ct > 3) return MKERROR_STRING(MKSTRING("Syntax: (map-find map key [default])")); map = CAR(args); if (NMAPP(map)) return MKERROR(MKSTRING("Expected a map in first arg to map-find"), map); key = CADR(args); res = map_find(&MAP(map), key); if (!res) { if (ct == 3) return CADDR(args); else return MKERROR(MKSTRING("Key not found."), key); } return res; }
static obj_ptr _map_clear(obj_ptr arg, obj_ptr env) { if (NMAPP(arg)) return MKERROR(MKSTRING("Expected a map in map-clear"), arg); map_clear(&MAP(arg)); return NIL; }