username
stringlengths
1
36
repo
stringlengths
1
82
path
stringlengths
4
161
function
stringlengths
0
328
code
stringlengths
15
240k
func_defs
stringlengths
0
313k
llvm
stringclasses
1 value
hash
stringlengths
64
64
memory
int64
15
240k
chriskmanx
qmole
QMOLEDEV/vnc-4_1_3-unixsrc/unix/xc/lib/GL/mesa/src/drv/mga/mgatris.c
mga_draw_quad
static void __inline__ mga_draw_quad( mgaContextPtr mmesa, mgaVertexPtr v0, mgaVertexPtr v1, mgaVertexPtr v2, mgaVertexPtr v3 ) { GLuint vertex_size = mmesa->vertex_size; GLuint *vb = mgaAllocDmaLow( mmesa, 6 * 4 * vertex_size ); int j; EMIT_VERT( j, vb, vertex_size, v0 ); EMIT_VERT( j, vb, vertex_size, v1 ); EMIT_VERT( j, vb, vertex_size, v3 ); EMIT_VERT( j, vb, vertex_size, v1 ); EMIT_VERT( j, vb, vertex_size, v2 ); EMIT_VERT( j, vb, vertex_size, v3 ); }
static void init_rast_tab( void ); static void mgaRenderClippedPoly( GLcontext *ctx, const GLuint *elts, GLuint n ); static void mgaRenderClippedLine( GLcontext *ctx, GLuint ii, GLuint jj ); static void mgaChooseRenderState(GLcontext *ctx); static void mgaRunPipeline( GLcontext *ctx ); void mgaRasterPrimitive( GLcontext *ctx, GLenum prim, GLuint hwprim ); static void mgaRenderPrimitive( GLcontext *ctx, GLenum prim ); static void mgaRenderFinish( GLcontext *ctx ); void mgaFallback( GLcontext *ctx, GLuint bit, GLboolean mode ); void mgaDDInitTriFuncs( GLcontext *ctx );
7e6b1dc08c7ef836c483ab960a9c8536da12027fc2e2e9498495320acb0994d2
533
alistairking
wandio
lib/ior-peek.c
peek_peek
static int64_t peek_peek(io_t *io, void *buffer, int64_t len) { int64_t ret = 0; int res = 0; if (DATA(io)->length - DATA(io)->offset < len) { int64_t read_amount = len - (DATA(io)->length - DATA(io)->offset); read_amount += PEEK_SIZE - ((DATA(io)->length + read_amount) % PEEK_SIZE); DATA(io)->buffer = alignedrealloc(DATA(io)->buffer, DATA(io)->length, DATA(io)->length + read_amount, &res); if (DATA(io)->buffer == NULL) { return res; } read_amount = wandio_read(DATA(io)->child, DATA(io)->buffer + DATA(io)->length, read_amount); if (read_amount < 0) { return read_amount; } DATA(io)->length += read_amount; } ret = MIN(len, DATA(io)->length - DATA(io)->offset); memcpy(buffer, DATA(io)->buffer + DATA(io)->offset, ret); return ret; }
DLLEXPORT io_t *peek_open(io_t *child); static int64_t refill_buffer(io_t *io, int64_t len); static int64_t peek_read(io_t *io, void *buffer, int64_t len); static void *alignedrealloc(void *old, size_t oldsize, size_t size, int *res); static int64_t peek_tell(io_t *io); static int64_t peek_seek(io_t *io, int64_t offset, int whence); static void peek_close(io_t *io);
dadab1821fca6a485e217f69180fe96d6fe254ea601a2aaa32862ba28aceab52
1,264
garbear
v4l-utils
lib/libdvbv5/dvb-file.c
parse_delsys
int parse_delsys(const char *name) { int i, cnt = 0; for (i = 0; i < ARRAY_SIZE(delivery_system_name); i++) if (delivery_system_name[i] && !strcasecmp(name, delivery_system_name[i])) break; if (i < ARRAY_SIZE(delivery_system_name)) return i; for (i = 0; i < ARRAY_SIZE(alt_names); i++) if (!strcasecmp(name, alt_names[i].name)) break; if (i < ARRAY_SIZE(alt_names)) return alt_names[i].delsys; fprintf(stderr, "ERROR: Delivery system %s is not known. Valid values are:\n", name); for (i = 0; i < ARRAY_SIZE(alt_names) - 1; i++) { if (!(cnt % 5)) fprintf(stderr, "\n"); fprintf(stderr, "%-15s", alt_names[i].name); cnt++; } for (i = 1; i < ARRAY_SIZE(delivery_system_name) - 1; i++) { if (!(cnt % 5)) fprintf(stderr, "\n"); fprintf(stderr, "%-15s", delivery_system_name[i]); cnt++; } if (cnt % 5) fprintf(stderr, "\n"); fprintf(stderr, "\n"); return -1; }
static void adjust_delsys(struct dvb_entry *entry); static uint32_t get_compat_format(uint32_t delivery_system); static int fill_entry(struct dvb_entry *entry, char *key, char *value); struct dvb_file *read_dvb_file(const char *fname); int write_dvb_file(const char *fname, struct dvb_file *dvb_file); static char *dvb_vchannel(struct dvb_v5_fe_parms *parms, struct dvb_table_nit *nit, uint16_t service_id); static int sort_other_el_pid(const void *a_arg, const void *b_arg); enum file_formats parse_format(const char *name);
496ebfdcb652d2352fd4d5f14e998c1e25e20a2cf9e89b666ae73e9388183a76
921
jmahler
EECE344-Digital_System_Design
empty_project/Libraries/STM32_TouchSensing_Driver/src/stm32_tsl_services.c
TSL_DeltaCalculation
void TSL_DeltaCalculation(void) { Delta = (int16_t)(pKeyStruct->Channel.Reference - pKeyStruct->Channel.LastMeas); }
void TSL_SetStructPointer(void); void TSL_SCKey_SetIdleState(void); void TSL_SCKey_BackToIdleState(void); void TSL_SCKey_SetPreDetectState(void); void TSL_SCKey_SetDetectedState(void); void TSL_SCKey_SetPostDetectState(void); void TSL_SCKey_BackToDetectedState(void); void TSL_SCKey_SetPreRecalibrationState(void); void TSL_SCKey_SetCalibrationState(void); void TSL_SCKey_SetErrorState(void); void TSL_SCKey_SetDisabledState(void); void TSL_SCKey_DxS(void); void TSL_SCKey_DetectionTimeout(void); void TSL_ECS(void); uint16_t TSL_MCKey_InitAcq(uint8_t channel); void TSL_MCKey_SetStructPointer(void); void TSL_MCKey_DeltaCalculation(uint8_t ChIdx); void TSL_MCKey_SetIdleState(void); void TSL_MCKey_BackToIdleState(void); void TSL_MCKey_SetPreDetectState(void); void TSL_MCKey_SetDetectedState(void); void TSL_MCKey_SetPostDetectState(void); void TSL_MCKey_BackToDetectedState(void); void TSL_MCKey_SetPreRecalibrationState(void); void TSL_MCKey_SetCalibrationState(void); void TSL_MCKey_SetErrorState(void); void TSL_MCKey_SetDisabledState(void); void TSL_MCKey_DxS(void); void TSL_MCKey_DetectionTimeout(void);
df8f52db3784c97363960c19c2a2f7b144760543eb261295cd17c0d2e82ee988
123
odit
rv042
linux/kernel_2.6/linux/fs/openpromfs/inode.c
check_space
static int __init check_space (u16 n) { unsigned long pages; if ((1 << alloced) * PAGE_SIZE < (n + 2) * sizeof(openpromfs_node)) { pages = __get_free_pages (GFP_KERNEL, alloced + 1); if (!pages) return -1; if (nodes) { memcpy ((char *)pages, (char *)nodes, (1 << alloced) * PAGE_SIZE); free_pages ((unsigned long)nodes, alloced); } alloced++; nodes = (openpromfs_node *)pages; } return 0; }
int property_release (struct inode *inode, struct file *filp); static int lookup_children(u16 n, const char * name, int len); static struct dentry *openpromfs_lookup(struct inode * dir, struct dentry *dentry, struct nameidata *nd); static int openpromfs_readdir(struct file * filp, void * dirent, filldir_t filldir); static int openpromfs_unlink (struct inode *dir, struct dentry *dentry); static u16 __init get_nodes (u16 parent, u32 node); static void openprom_read_inode(struct inode * inode); static int openprom_remount(struct super_block *sb, int *flags, char *data); static int openprom_fill_super(struct super_block *s, void *data, int silent); static int __init init_openprom_fs(void); static void __exit exit_openprom_fs(void);
ae08c29502a531e0a2063e35f62dde35f5fa2d2b62efbfbb5bc69cf580e9c6e4
422
sdudley
maximus
install/cvt202.c
CvtParse
static void CvtParse(void) { char szTemp[MAX_CTL_LINE]; char szLine[MAX_CTL_LINE]; char szStrippedLine[MAX_CTL_LINE]; char szKeyword[MAX_CTL_LINE]; int iWord; CVTPARM cp; CVTSTATE csOld; while (fgets(szLine, MAX_CTL_LINE, pfsCur->fpIn)) { pfsCur->iLine++; strcpy(szStrippedLine, szLine); StripComment(szStrippedLine); getword(szStrippedLine, szKeyword, szCtlDelim, 1); memset(cp.szWords, 0, sizeof cp.szWords); iWord = 0; do { getword(szStrippedLine, szTemp, szCtlDelim, iWord+1); if (*szTemp) cp.szWords[iWord++] = sstrdup(szTemp); else cp.szWords[iWord++] = NULL; } while (*szTemp); cp.szLine = szLine; cp.szStrippedLine = szStrippedLine; cp.szKeyword = szKeyword; do_xlat(&cp, xtTop); if (ptsTables[csState].pxt) do_xlat(&cp, ptsTables[csState].pxt); csOld = csState; handle_keyword(&cp, ptsTables[csState].ptt); for (iWord=0; cp.szWords[iWord]; iWord++) free(cp.szWords[iWord]); if (!ptsTables[csOld].fHaltOutput || csState != csOld) fprintf(pfsCur->fpOut, "%s", szLine); } }
CVTSTATE HandleEventEvent(CVTPARM *pcp); CVTSTATE HandleSystemEnd(CVTPARM *pcp); CVTSTATE HandleSystemFile(CVTPARM *pcp); CVTSTATE HandleMatrixEnd(CVTPARM *pcp); CVTSTATE HandleMenuHeader(CVTPARM *pcp); CVTSTATE HandleHeaderFile(CVTPARM *pcp); CVTSTATE HandleMenuDefault(CVTPARM *pcp); CVTSTATE HandleMenuEnd(CVTPARM *pcp); CVTSTATE HandleColourStrip(CVTPARM *pcp); CVTSTATE HandleColourEnd(CVTPARM *pcp); CVTSTATE HandleLanguageStrip(CVTPARM *pcp); CVTSTATE HandleLanguageEnd(CVTPARM *pcp); CVTSTATE HandleSessionUpload(CVTPARM *pcp); CVTSTATE HandleSessionNo(CVTPARM *pcp); CVTSTATE HandleSessionStrip(CVTPARM *pcp); CVTSTATE HandleSessionFormat(CVTPARM *pcp); CVTSTATE HandleSessionArea(CVTPARM *pcp); CVTSTATE HandleSessionBegin(CVTPARM *pcp); CVTSTATE HandleSessionEnd(CVTPARM *pcp); CVTSTATE HandleAreaEnd(CVTPARM *pcp); CVTSTATE HandleAreaMsgInfo(CVTPARM *pcp); CVTSTATE HandleAreaMsgAccess(CVTPARM *pcp); CVTSTATE HandleAreaType(CVTPARM *pcp); CVTSTATE HandleAreaRenum(CVTPARM *pcp); CVTSTATE HandleAreaMsgMenuName(CVTPARM *pcp); CVTSTATE HandleAreaMsgName(CVTPARM *pcp); CVTSTATE HandleAreaMatrix(CVTPARM *pcp); CVTSTATE HandleAreaEcho(CVTPARM *pcp); CVTSTATE HandleAreaConf(CVTPARM *pcp); CVTSTATE HandleAreaLocal(CVTPARM *pcp); CVTSTATE HandleAreaPublic(CVTPARM *pcp); CVTSTATE HandleAreaPrivate(CVTPARM *pcp); CVTSTATE HandleAreaAlias(CVTPARM *pcp); CVTSTATE HandleAreaReadOnly(CVTPARM *pcp); CVTSTATE HandleAreaAnonymous(CVTPARM *pcp); CVTSTATE HandleAreaHigh(CVTPARM *pcp); CVTSTATE HandleAreaNoNameKludge(CVTPARM *pcp); CVTSTATE HandleAreaUseRealname(CVTPARM *pcp); CVTSTATE HandleAreaOrigin(CVTPARM *pcp); CVTSTATE HandleAreaMsgOverride(CVTPARM *pcp); CVTSTATE HandleAreaMsgBarricade(CVTPARM *pcp); CVTSTATE HandleAreaDownload(CVTPARM *pcp); CVTSTATE HandleAreaUpload(CVTPARM *pcp); CVTSTATE HandleAreaFileInfo(CVTPARM *pcp); CVTSTATE HandleAreaFileAccess(CVTPARM *pcp); CVTSTATE HandleAreaFileMenuName(CVTPARM *pcp); CVTSTATE HandleAreaFileList(CVTPARM *pcp); CVTSTATE HandleAreaFileOverride(CVTPARM *pcp); CVTSTATE HandleAreaFileBarricade(CVTPARM *pcp); CVTSTATE HandleAreaObsolete(CVTPARM *pcp); CVTSTATE HandleAreaApp(CVTPARM *pcp); CVTSTATE HandleAreaPrivRelated(CVTPARM *pcp); CVTSTATE HandleTopSystem(CVTPARM *pcp); CVTSTATE HandleTopMatrix(CVTPARM *pcp); CVTSTATE HandleTopColour(CVTPARM *pcp); CVTSTATE HandleTopLanguage(CVTPARM *pcp); CVTSTATE HandleTopSession(CVTPARM *pcp); CVTSTATE HandleTopMenu(CVTPARM *pcp); CVTSTATE HandleTopArea(CVTPARM *pcp); CVTSTATE HandleTopInclude(CVTPARM *pcp); dword SqHash(byte *f); static void set_status(char *pszName); void Unknown(char *szWhat, char *szValue); char *fchar(char *str,char *delim,int wordno); static void CvtInit(void); static void near set_extension(char *szName, char *szNewExt); static int query_overwrite(char *szName); static void fatal_file_err(char *szErrFmt, char *szName); void StripComment(char *szLine); static void do_xlat(CVTPARM *pcp, XLATTABLE *pxt); static void handle_keyword(CVTPARM *pcp, TRANSLATOR *pttTable); static void CvtFile(char *pszName); void CvtConfig(char *szCfg, char *szPrm); static void CvtTag(char *szTag); static void CvtEvents(char *szFilespec); void set_files_base(char *szBase); MenuFunction(ValFile);
4e67c5b0e4f883a4ec32b3cc5a6b9ca431e1e14cb829e47a54928372359a2923
1,178
RDemers
org.rd.qtx.toolboxlib
QtxToolboxLib/DecNumber/decBasic.c
decFloatRemainder
decFloat * decFloatRemainder(decFloat *result, const decFloat *dfl, const decFloat *dfr, decContext *set) { return decDivide(result, dfl, dfr, set, REMAINDER); }
static decFloat * decCanonical(decFloat *result, const decFloat *df); decFloat * decFloatCanonical(decFloat *result, const decFloat *df); enum decClass decFloatClass(const decFloat *df); const char *decFloatClassString(const decFloat *df); decFloat * decFloatCopy(decFloat *result, const decFloat *dfl); decFloat * decFloatCopyAbs(decFloat *result, const decFloat *dfl); decFloat * decFloatCopyNegate(decFloat *result, const decFloat *dfl); uInt decFloatDigits(const decFloat *df); decFloat * decFloatFromInt32(decFloat *result, Int n); decFloat * decFloatFromUInt32(decFloat *result, uInt u); uInt decFloatIsCanonical(const decFloat *df); uInt decFloatIsFinite(const decFloat *df); uInt decFloatIsInfinite(const decFloat *df); uInt decFloatIsInteger(const decFloat *df); uInt decFloatIsLogical(const decFloat *df); uInt decFloatIsNaN(const decFloat *df); uInt decFloatIsNegative(const decFloat *df); uInt decFloatIsNormal(const decFloat *df); uInt decFloatIsPositive(const decFloat *df); uInt decFloatIsSignaling(const decFloat *df); uInt decFloatIsSignalling(const decFloat *df); uInt decFloatIsSigned(const decFloat *df); uInt decFloatIsSubnormal(const decFloat *df); uInt decFloatIsZero(const decFloat *df); uInt decFloatSameQuantum(const decFloat *dfl, const decFloat *dfr); static decFloat *decInvalid(decFloat *result, decContext *set); static decFloat *decInfinity(decFloat *result, const decFloat *df); static Int decNumCompare(const decFloat *dfl, const decFloat *dfr, Flag tot);
f4a4054fc6acb5b78c3c180ff427437e10a44ce732813730b2ad8b5ef92263c4
228
cranes-bill
cedit
plugins/spell/cedit-spell-checker.c
void cedit_spell_checker_get_property
static void cedit_spell_checker_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { switch (prop_id) { case PROP_LANGUAGE: default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); } }
4a814fefe4f9256addcbc70ee8b8d21e382f499e295c2af2fb879e12cb4f7947
263
0xD34D
kernel_omap_bowser-common
arch/arm/mach-omap2/omap_hwmod.c
omap_hwmod_disable_wakeup
int omap_hwmod_disable_wakeup(struct omap_hwmod *oh) { unsigned long flags; u32 v; if (!oh->class->sysc || !(oh->class->sysc->sysc_flags & SYSC_HAS_ENAWAKEUP)) return -EINVAL; spin_lock_irqsave(&oh->_lock, flags); v = oh->_sysc_cache; _disable_wakeup(oh, &v); _write_sysconfig(v, oh); omap_hwmod_disable_ioring_wakeup(oh); spin_unlock_irqrestore(&oh->_lock, flags); return 0; }
static int _update_sysc_cache(struct omap_hwmod *oh); static void _write_sysconfig_raw(u32 v, struct omap_hwmod *oh); static void _write_sysconfig(u32 v, struct omap_hwmod *oh); static int _set_master_standbymode(struct omap_hwmod *oh, u8 standbymode, u32 *v); static int _set_slave_idlemode(struct omap_hwmod *oh, u8 idlemode, u32 *v); static int _set_clockactivity(struct omap_hwmod *oh, u8 clockact, u32 *v); static int _set_softreset(struct omap_hwmod *oh, u32 *v); static int _set_module_autoidle(struct omap_hwmod *oh, u8 autoidle, u32 *v); static int _enable_wakeup(struct omap_hwmod *oh, u32 *v); static int _disable_wakeup(struct omap_hwmod *oh, u32 *v); static int _add_initiator_dep(struct omap_hwmod *oh, struct omap_hwmod *init_oh); static int _del_initiator_dep(struct omap_hwmod *oh, struct omap_hwmod *init_oh); static int _init_main_clk(struct omap_hwmod *oh); static int _init_interface_clks(struct omap_hwmod *oh); static int _init_opt_clks(struct omap_hwmod *oh); static int _enable_clocks(struct omap_hwmod *oh); static int _disable_clocks(struct omap_hwmod *oh); static void _enable_optional_clocks(struct omap_hwmod *oh); static void _disable_optional_clocks(struct omap_hwmod *oh); static int __init _find_mpu_port_index(struct omap_hwmod *oh); static void __iomem * __init _find_mpu_rt_base(struct omap_hwmod *oh, u8 index); static void _enable_sysc(struct omap_hwmod *oh); static void _idle_sysc(struct omap_hwmod *oh); static void _shutdown_sysc(struct omap_hwmod *oh); static struct omap_hwmod *_lookup(const char *name); static int _init_clocks(struct omap_hwmod *oh, void *data); static int _wait_target_ready(struct omap_hwmod *oh); static u8 _lookup_hardreset(struct omap_hwmod *oh, const char *name, struct omap_hwmod_rst_info *ohri); static int _assert_hardreset(struct omap_hwmod *oh, const char *name); static int _deassert_hardreset(struct omap_hwmod *oh, const char *name); static int _read_hardreset(struct omap_hwmod *oh, const char *name); static int _ocp_softreset(struct omap_hwmod *oh); static int _reset(struct omap_hwmod *oh); static int _enable(struct omap_hwmod *oh); static int _idle(struct omap_hwmod *oh); int omap_hwmod_set_ocp_autoidle(struct omap_hwmod *oh, u8 autoidle); static int _shutdown(struct omap_hwmod *oh); static int _setup(struct omap_hwmod *oh, void *data); static int __init _register(struct omap_hwmod *oh); u32 omap_hwmod_read(struct omap_hwmod *oh, u16 reg_offs); void omap_hwmod_write(u32 v, struct omap_hwmod *oh, u16 reg_offs); int omap_hwmod_softreset(struct omap_hwmod *oh); int omap_hwmod_set_slave_idlemode(struct omap_hwmod *oh, u8 idlemode); struct omap_hwmod *omap_hwmod_lookup(const char *name); int omap_hwmod_for_each(int (*fn); int __init omap_hwmod_register(struct omap_hwmod **ohs); static int __init _populate_mpu_rt_base(struct omap_hwmod *oh, void *data); int __init omap_hwmod_setup_one(const char *oh_name); static int __init omap_hwmod_setup_all(void); static int omap_hwmod_set_ioring_wakeup(struct omap_hwmod *oh, bool set_wake); static bool omap_hwmod_get_ioring_wakeup_status(struct omap_hwmod *oh); int omap_hwmod_enable(struct omap_hwmod *oh); int omap_hwmod_idle(struct omap_hwmod *oh); int omap_hwmod_shutdown(struct omap_hwmod *oh); int omap_hwmod_enable_clocks(struct omap_hwmod *oh); int omap_hwmod_disable_clocks(struct omap_hwmod *oh); void omap_hwmod_ocp_barrier(struct omap_hwmod *oh); int omap_hwmod_reset(struct omap_hwmod *oh); int omap_hwmod_count_resources(struct omap_hwmod *oh); int omap_hwmod_fill_resources(struct omap_hwmod *oh, struct resource *res); struct powerdomain *omap_hwmod_get_pwrdm(struct omap_hwmod *oh); void __iomem *omap_hwmod_get_mpu_rt_va(struct omap_hwmod *oh); int omap_hwmod_add_initiator_dep(struct omap_hwmod *oh, struct omap_hwmod *init_oh); int omap_hwmod_del_initiator_dep(struct omap_hwmod *oh, struct omap_hwmod *init_oh); int omap_hwmod_enable_ioring_wakeup(struct omap_hwmod *oh); int omap_hwmod_disable_ioring_wakeup(struct omap_hwmod *oh); int omap_hwmod_enable_wakeup(struct omap_hwmod *oh); int omap_hwmod_assert_hardreset(struct omap_hwmod *oh, const char *name); int omap_hwmod_deassert_hardreset(struct omap_hwmod *oh, const char *name); int omap_hwmod_read_hardreset(struct omap_hwmod *oh, const char *name); int omap_hwmod_for_each_by_class(const char *classname, int (*fn); int omap_hwmod_set_postsetup_state(struct omap_hwmod *oh, u8 state); int omap_hwmod_get_context_loss_count(struct omap_hwmod *oh); int omap_hwmod_no_setup_reset(struct omap_hwmod *oh); int omap_hwmod_pad_get_wakeup_status(struct omap_hwmod *oh); bool omap_hwmod_pad_is_ioring_enabled(struct omap_hwmod *oh); struct device *omap_hwmod_name_get_dev(const char *oh_name);
b60090da6f01cd5737e5df62cb3a7a888668a0302d37f26bd6ccb67fefa0681a
398
SAOImageDS9
SAOImageDS9
ast/src/selectormap.c
Delete
static void Delete( AstObject *obj, int *status ) { AstSelectorMap *this; int i; this = (AstSelectorMap *) obj; for( i = 0; i < this->nreg; i++ ) { this->reg[ i ] = astAnnul( this->reg[ i ] ); } this->reg = astFree( this->reg ); this->nreg = 0; }
static int Equal( AstObject *this_object, AstObject *that_object, int *status ); static size_t GetObjSize( AstObject *this_object, int *status ); void astInitSelectorMapVtab_( AstSelectorMapVtab *vtab, const char *name, int *status ); static void Copy( const AstObject *objin, AstObject *objout, int *status ); static void Dump( AstObject *this_object, AstChannel *channel, int *status ); astMAKE_CHECK(SelectorMap);
65e3b02b3d03e60b5fe3151740a9d7565960753561809e2ba176f5c0b9d7cf76
303
ntfreak
openocd
src/target/riscv/riscv-013.c
dmi_read
static int dmi_read(struct target *target, uint32_t *value, uint32_t address) { return dmi_op(target, value, NULL, DMI_OP_READ, address, 0, false, true); }
static riscv013_info_t *get_info(const struct target *target); dm013_info_t *get_dm(struct target *target); static uint32_t set_hartsel(uint32_t initial, uint32_t index); static void decode_dmi(char *text, unsigned address, unsigned data); static void dump_field(int idle, const struct scan_field *field); static void select_dmi(struct target *target); static uint32_t dtmcontrol_scan(struct target *target, uint32_t out); static void increase_dmi_busy_delay(struct target *target); static int dmi_read_exec(struct target *target, uint32_t *value, uint32_t address); static int dmi_write(struct target *target, uint32_t address, uint32_t value); static void increase_ac_busy_delay(struct target *target); uint32_t abstract_register_size(unsigned width); static int wait_for_idle(struct target *target, uint32_t *abstractcs); static int execute_abstract_command(struct target *target, uint32_t command); static uint32_t abstract_memory_size(unsigned width); static int examine_progbuf(struct target *target); static int is_fpu_reg(uint32_t gdb_regno); static int is_vector_reg(uint32_t gdb_regno); static unsigned register_size(struct target *target, unsigned number); static bool has_sufficient_progbuf(struct target *target, unsigned size); static int register_read(struct target *target, uint64_t *value, uint32_t number); static int register_read_direct(struct target *target, uint64_t *value, uint32_t number); int wait_for_authbusy(struct target *target, uint32_t *dmstatus); static void deinit_target(struct target *target); static int set_haltgroup(struct target *target, bool *supported); static int discover_vlenb(struct target *target, int hartid); static int examine(struct target *target); int riscv013_authdata_read(struct target *target, uint32_t *value); int riscv013_authdata_write(struct target *target, uint32_t value); static int riscv013_hart_count(struct target *target); static unsigned riscv013_data_bits(struct target *target); static int assert_reset(struct target *target); static int deassert_reset(struct target *target); static int execute_fence(struct target *target); static uint32_t sb_sbaccess(unsigned size_bytes); static target_addr_t sb_read_address(struct target *target); static int sb_write_address(struct target *target, target_addr_t address); static int read_sbcs_nonbusy(struct target *target, uint32_t *sbcs); static int modify_privilege(struct target *target, uint64_t *mstatus, uint64_t *mstatus_old); static int batch_run(const struct target *target, struct riscv_batch *batch); static int arch_state(struct target *target); static int riscv013_set_register(struct target *target, int hid, int rid, uint64_t value); static int riscv013_select_current_hart(struct target *target); static int select_prepped_harts(struct target *target, bool *use_hasel); static int riscv013_halt_prep(struct target *target); static int riscv013_halt_go(struct target *target); static int riscv013_resume_go(struct target *target); static int riscv013_step_current_hart(struct target *target); static int riscv013_resume_prep(struct target *target); static int riscv013_on_step(struct target *target); static int riscv013_on_halt(struct target *target); static bool riscv013_is_halted(struct target *target); static enum riscv_halt_reason riscv013_halt_reason(struct target *target); int riscv013_write_debug_buffer(struct target *target, unsigned index, riscv_insn_t data); riscv_insn_t riscv013_read_debug_buffer(struct target *target, unsigned index); int riscv013_execute_debug_buffer(struct target *target); void riscv013_fill_dmi_write_u64(struct target *target, char *buf, int a, uint64_t d); void riscv013_fill_dmi_read_u64(struct target *target, char *buf, int a); void riscv013_fill_dmi_nop_u64(struct target *target, char *buf); static int get_max_sbaccess(struct target *target); static uint32_t get_num_sbdata_regs(struct target *target); int riscv013_dmi_write_u64_bits(struct target *target); static int maybe_execute_fence_i(struct target *target); static int riscv013_on_step_or_resume(struct target *target, bool step); void riscv013_clear_abstract_error(struct target *target); int riscv013_test_compliance(struct target *target);
a27314d950d52cef581f6a6b4a34ebb344f339d18eb4c40837ca405dbcf8bf4b
157
osvx
pmacct
src/sql_handlers.c
count_dst_host_country_handler
void count_dst_host_country_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where) { snprintf(*ptr_where, SPACELEFT(where_clause), where[num].string, GeoIP_code_by_id(cache_elem->primitives.dst_ip_country)); snprintf(*ptr_values, SPACELEFT(values_clause), values[num].string, GeoIP_code_by_id(cache_elem->primitives.dst_ip_country)); *ptr_where += strlen(*ptr_where); *ptr_values += strlen(*ptr_values); }
void count_src_mac_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_dst_mac_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_vlan_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_cos_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_etype_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_src_host_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_src_as_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_dst_host_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_dst_as_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_in_iface_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_out_iface_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_src_nmask_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_dst_nmask_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_src_host_country_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_sampling_rate_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_pkt_len_distrib_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_post_nat_src_ip_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_post_nat_dst_ip_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_post_nat_src_port_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_post_nat_dst_port_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_nat_event_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void PG_copy_count_timestamp_start_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_timestamp_start_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_timestamp_start_residual_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void PG_copy_count_timestamp_end_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_timestamp_end_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_timestamp_end_residual_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_std_comm_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_ext_comm_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_as_path_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_src_std_comm_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_src_ext_comm_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_src_as_path_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_local_pref_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_src_local_pref_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_med_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_src_med_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_mpls_vpn_rd_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_peer_src_as_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_peer_dst_as_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_peer_src_ip_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_peer_dst_ip_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_src_port_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_dst_port_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_tcpflags_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_ip_tos_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void MY_count_ip_proto_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void PG_count_ip_proto_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_copy_timestamp_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_timestamp_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_id_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_id2_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_class_id_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void count_counters_setclause_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_set, char **ptr_none); void count_flows_setclause_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_set, char **ptr_none); void count_tcpflags_setclause_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_set, char **ptr_none); void count_noop_setclause_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_set, char **ptr_none); void count_noop_setclause_event_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_set, char **ptr_none); void fake_mac_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void fake_host_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void fake_as_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void fake_comms_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where); void fake_as_path_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
ffc048aae33cee4d6345299ad92cf6ea7b8e813f3c798f1aeb97c9a84934a252
481
MattDevo
coreboot
src/lib/ramtest.c
write_phys
static void write_phys(unsigned long addr, u32 value) { #if IS_ENABLED(CONFIG_SSE2) asm volatile( "movnti %1, (%0)" : : "r" (addr), "r" (value) #ifndef __GNUC__ : #endif ); #else volatile unsigned long *ptr; ptr = (void *)addr; *ptr = value; #endif }
static u32 read_phys(unsigned long addr); static void phys_memory_barrier(void); static int ram_bitset_nodie(unsigned long start); void ram_check(unsigned long start, unsigned long stop); int ram_check_nodie(unsigned long start, unsigned long stop); int ram_check_noprint_nodie(unsigned long start, unsigned long stop); static void __quick_ram_check(uintptr_t dst); void quick_ram_check(void);
9274c8ad3d6e8441fb8ffcfe3a88c40e2452b5ff220c650461faf754bd86c1bc
279
emacs-mirror
emacs
src/keyboard.c
AVOID user_error
static AVOID user_error (const char *msg) { xsignal1 (Quser_error, build_string (msg)); }
FOR_EACH_TAIL_SAFE (event_desc); void init_raw_keybuf_count (void);
fd4814738aed49f5b526ff201f355606604527540ab92b8391da090ad53dd156
92
Angor00
linux-aura-hd-android-2.6.35.3
drivers/mxc/pmic/mc13892/pmic_adc.c
pmic_adc_convert_8x
PMIC_STATUS pmic_adc_convert_8x(t_channel channel, unsigned short *result) { t_adc_param adc_param; int i; PMIC_STATUS ret; if (suspend_flag == 1) return -EBUSY; channel = channel_num[channel]; if (channel == -1) { pr_debug("Wrong channel ID\n"); return PMIC_PARAMETER_ERROR; } mc13892_adc_init_param(&adc_param); pr_debug("pmic_adc_convert_8x\n"); adc_param.read_ts = false; adc_param.single_channel = true; adc_param.read_mode = mc13892_set_read_mode(channel); if (channel <= 7) { adc_param.channel_0 = channel; adc_param.channel_1 = channel; } else return PMIC_PARAMETER_ERROR; ret = mc13892_adc_convert(&adc_param); for (i = 0; i <= 7; i++) result[i] = adc_param.value[i]; return ret; }
int is_pmic_adc_ready(); static int pmic_adc_suspend(struct platform_device *pdev, pm_message_t state); static int pmic_adc_resume(struct platform_device *pdev); static void callback_tsi(void *unused); static void callback_adcdone(void *unused); static void callback_adcbisdone(void *unused); static int pmic_adc_filter(t_touch_screen *ts_curr); int pmic_adc_init(void); PMIC_STATUS pmic_adc_deinit(void); int mc13892_adc_init_param(t_adc_param *adc_param); PMIC_STATUS mc13892_adc_convert(t_adc_param *adc_param); t_reading_mode mc13892_set_read_mode(t_channel channel); PMIC_STATUS pmic_adc_convert(t_channel channel, unsigned short *result); PMIC_STATUS pmic_adc_set_touch_mode(t_touch_mode touch_mode); PMIC_STATUS pmic_adc_get_touch_mode(t_touch_mode *touch_mode); PMIC_STATUS pmic_adc_get_touch_sample(t_touch_screen *touch_sample, int wait); PMIC_STATUS mc13892_adc_read_ts(t_touch_screen *ts_value, int wait_tsi); int mc13892_adc_request(bool read_ts); int mc13892_adc_release(int adc_index); static int cmd(unsigned int index, int value); static int pmic_adc_module_probe(struct platform_device *pdev); static int pmic_adc_module_remove(struct platform_device *pdev); static int __init pmic_adc_module_init(void); static void __exit pmic_adc_module_exit(void);
52c7e99c643d98a68e9d7c2a380d8735afd0bb755baf47b0dc8cc45810012e4c
727
ArcticVanguard
navalcombat
navalcombat.c
int genrand
int genrand(int a) { int r = rand(); return r % a; }
float calcforce(float m, float a); void main();
4756f4c4307480b1f10b630917b716946396c53fcb3e1f6df0be9c47d1f3d90a
55
Sidnioulz
Planner
libplanner/mrp-task.c
* mrp_task_set_unit_ivals
GList * mrp_task_set_unit_ivals (MrpTask *task, GList *ivals) { g_return_val_if_fail (MRP_IS_TASK (task), 0); if (task->priv->unit_ivals) { g_list_foreach (task->priv->unit_ivals, (GFunc) g_free, NULL); g_list_free (task->priv->unit_ivals); task->priv->unit_ivals = NULL; } task->priv->unit_ivals = ivals; return task->priv->unit_ivals; }
void mrp_task_set_name (MrpTask *task, const gchar *name); gint mrp_task_get_nres (MrpTask *task);
6bc7a3335a6b4e41df9e2bd4ba157bb9ef8b8ee0ea0ccd3b5c0ee9795af04ab7
352
muggenhor
GNUnet
src/gns/plugin_block_gns.c
* libgnunet_plugin_block_gns_done
void * libgnunet_plugin_block_gns_done (void *cls) { struct GNUNET_TRANSPORT_PluginFunctions *api = cls; GNUNET_free (api); return NULL; }
2eaa960d46cb5b0d18401692cfa1f1d62d8a8efaa50a9ecdd6c76736261542f0
146
hyller
CodeLibrary
ZigBee/Z-Stack 3.0.0/Components/stack/zcl/zcl_green_power.c
gp_CreateNotificationMsgList
void gp_CreateNotificationMsgList( gpNotificationMsg_t **pHead ) { if ( *pHead == NULL ) { *pHead = ( gpNotificationMsg_t* )osal_mem_alloc( sizeof( gpNotificationMsg_t ) ); if ( *pHead != NULL ) { (*pHead)->pNext = NULL; } } return; }
ZStatus_t zclGp_RegisterCmdCallbacks( uint8 endpoint, zclGp_AppCallbacks_t *callbacks ); static zclGp_AppCallbacks_t *zclGp_FindCallbacks( uint8 endpoint ); static ZStatus_t zclGp_HdlIncoming( zclIncoming_t *pInMsg ); static ZStatus_t zclGp_HdlInSpecificCommands( zclIncoming_t *pInMsg ); ZStatus_t zclGp_SendGpNotificationCommand( gpNotificationCmd_t *pCmd ); ZStatus_t zclGp_SendGpCommissioningNotificationCommand( gpCommissioningNotificationCmd_t *pCmd ); static uint8 gp_addPairedSinksToMsgQueue( uint8 appId, uint8 *pId, gpCmdPayloadMsg_t* pMsg ); void gp_CreateCmdPayloadMsgList( gpCmdPayloadMsg_t **pHead ); gpNotificationMsg_t* gp_AddNotificationMsgNode( gpNotificationMsg_t **pHead, gpCmdPayloadMsg_t *pMsg ); gpCmdPayloadMsg_t* gp_AddCmdPayloadMsgNode( gpCmdPayloadMsg_t **pHead, uint8* pBuf, uint8 len ); gpNotificationMsg_t* gp_GetHeadNotificationMsg(void); gpNotificationMsg_t** gp_GetPHeadNotification(void); gpCmdPayloadMsg_t* gp_GetHeadCmdPayloadMsg(void); gpCmdPayloadMsg_t** gp_GetPHeadCmdPayload(void); void gp_NotificationMsgClean( gpNotificationMsg_t **pHead ); void gp_CmdPayloadMsgClean( gpCmdPayloadMsg_t **pHead );
2c24d58efbfdb8c47f6250c1de31c3950019322378571a3c6a01b1e2f46f12c0
288
371816210
kk44
drivers/usb/dwc_otg/usbdev_rk3026.c
usbdev_init_devices
static int __init usbdev_init_devices(void) { int ret = 0; #ifdef CONFIG_USB20_OTG ret = platform_device_register(&device_usb20_otg); if(ret < 0){ printk("%s: platform_device_register(usb20_otg) failed\n", __func__); return ret; } #endif #ifdef CONFIG_USB20_HOST ret = platform_device_register(&device_usb20_host); #endif return ret; }
int dwc_otg_check_dpdm(void); void usb20otg_hw_init(void); void usb20otg_phy_suspend(void* pdata, int suspend); void usb20otg_soft_reset(void); void usb20otg_clock_init(void* pdata); void usb20otg_clock_enable(void* pdata, int enable); int usb20otg_get_status(int id); void dwc_otg_uart_mode(void* pdata, int enter_usb_uart_mode); void usb20otg_power_enable(int enable); void usb20host_hw_init(void); void usb20host_phy_suspend(void* pdata, int suspend); void usb20host_soft_reset(void); void usb20host_clock_init(void* pdata); void usb20host_clock_enable(void* pdata, int enable); int usb20host_get_status(int id); void usb20host_power_enable(int enable); inline void do_wakeup(void); static irqreturn_t bvalid_irq_handler(int irq, void *dev_id); static irqreturn_t id_irq_handler(int irq, void *dev_id); static irqreturn_t line_irq_handler(int irq, void *dev_id); static int __init otg_irq_detect_init(void);
7efcd89401016d47fadfc2b862de1be382ac9efe436a73a5cef46b4e3e142ecd
402
ORNL-TechInt
lustre
lustre/utils/loadgen.c
loadgen_start_echosrv
static int loadgen_start_echosrv(int argc, char **argv) { char *args[5]; int rc; pthread_mutex_lock(&m_config); args[0] = cmdname; args[1] = "obdecho"; args[2] = args[3] = ecsname; rc = jt_lcfg_attach(4, args); if (rc) { fprintf(stderr, "%s: can't attach echo server (%d)\n", cmdname, rc); goto clean; } my_ecs = 1; rc = jt_lcfg_setup(1, args); if (rc) { fprintf(stderr, "%s: can't setup echo server (%d)\n", cmdname, rc); goto clean; } args[1] = "ost"; args[2] = args[3] = "OSS"; rc = jt_lcfg_attach(4, args); if (rc == EEXIST) { printf("OSS already set up, no problem.\n"); pthread_mutex_unlock(&m_config); return 0; } if (rc) { fprintf(stderr, "%s: can't attach OSS (%d)\n", cmdname, rc); goto clean; } my_oss = 1; rc = jt_lcfg_setup(1, args); if (rc) { fprintf(stderr, "%s: can't setup OSS (%d)\n", cmdname, rc); goto clean; } pthread_mutex_unlock(&m_config); return rc; clean: pthread_mutex_unlock(&m_config); loadgen_stop_echosrv(9, argv); return rc; }
static int jt_quit(int argc, char **argv); static int loadgen_usage(int argc, char **argv); static struct kid_t *push_kid(int tnum); static void trigger(int command, int threads, int repeat, int delay); static __inline__ void stop_all(int unused); static void kill_kids(void); static void sig_master(int unused); static int wait_for_threads(); static int write_proc(char *proc_path, char *value); static int read_proc(char *proc_path, unsigned long long *value); static int grant_estimate(int thread); static int cleanup(char *obdname, int quiet); static int echocli_setup(char *oname, char *ename, int *dev); static int obj_ioctl(int cmd, struct obd_ioctl_data *data, int unpack); static int obj_create(struct kid_t *kid); static int obj_delete(struct kid_t *kid); static int obj_write(struct kid_t *kid); static int do_work(struct kid_t *kid); static void report_perf(); static void *run_one_child(void *threadvp); static int loadgen_start_clients(int argc, char **argv); static int loadgen_target(int argc, char **argv); static int loadgen_verbose(int argc, char **argv); static int loadgen_write(int argc, char **argv); static int loadgen_stop_echosrv(int argc, char **argv); static int loadgen_wait(int argc, char **argv); static int loadgen_init(int argc, char **argv); static int loadgen_exit(); static int loadgen_main(int argc, char **argv); int main (int argc, char **argv);
4816a1fbe94f9168fb55947bad703d633bb4e2e0721fe9d731822b40e58adffa
1,558
alan-mushi
connman-json-client
engine.c
react_to_sig_technology
static void react_to_sig_technology(struct json_object *interface, struct json_object *path, struct json_object *data, const char *sig_name) { char tech_dbus_name[256]; struct json_object *tech, *tech_dict, *val; const char *key; snprintf(tech_dbus_name, 256, "/net/connman/technology/%s", json_object_get_string(path)); tech_dbus_name[255] = '\0'; tech = search_technology_or_service(technologies, tech_dbus_name); if (!tech) return; key = json_object_get_string(json_object_array_get_idx(data, 0)); val = json_object_array_get_idx(data, 1); tech_dict = json_object_array_get_idx(tech, 1); if (tech_dict && json_object_object_get_ex(tech_dict, key, NULL)) { json_object_object_del(tech_dict, key); json_object_object_add(tech_dict, key, json_object_get(val)); } }
static void engine_commands_cb(struct json_object *data, json_bool is_error); static void engine_agent_cb(struct json_object *data, struct agent_data *request); static void engine_agent_error_cb(struct json_object *data); static int agent_response(struct json_object *data); static int agent_error_response(struct json_object *data); static struct json_object* get_technology(const char *dbus_name); static bool has_technology(const char *dbus_name); static struct json_object* get_service(const char *dbus_name); static bool has_service(const char *dbus_name); static int init_get_state(void); static int init_get_technologies(void); static int init_get_services(void); static int get_state(struct json_object *jobj); static int get_services(struct json_object *jobj); static int get_technologies(struct json_object *jobj); static int get_home_page(struct json_object *jobj); static int get_services_from_tech(struct json_object *jobj); static int connect_to_service(struct json_object *jobj); static int disconnect_technology(struct json_object *jobj); static int scan_technology(struct json_object *jobj); static int config_service(struct json_object *jobj); static int toggle_power_technology(struct json_object *jobj); static int toggle_offline_mode(struct json_object *jobj); static int remove_service(struct json_object *jobj); static int engine_get_service(struct json_object *jobj); static void init_cmd_table(void); static int command_exist(const char *cmd); static bool command_data_is_clean(struct json_object *jobj, int cmd_pos); static void engine_commands_sig(struct json_object *jobj); int engine_query(struct json_object *jobj); int engine_init(void); void engine_terminate(void);
5bb1c09b02bb22932889c7677ac7a051c7c2a7eff4c5ddf1e543b3063cd7eb79
793
vipshop
redis-migrate-tool
src/rmt_redis.c
*sendReplSyncCommand
static char *sendReplSyncCommand(int flags, redis_node *srnode, ...) { tcp_context *tc = srnode->tc; redis_repl *rr = srnode->rr; thread_data *rdata = srnode->read_data; if (flags & SYNC_CMD_WRITE) { char *arg; va_list ap; sds cmd = sdsempty(); va_start(ap,srnode); while(1) { arg = va_arg(ap, char*); if (arg == NULL) break; if (sdslen(cmd) != 0) cmd = sdscatlen(cmd," ",1); cmd = sdscat(cmd,arg); } cmd = sdscatlen(cmd,"\r\n",2); if (rmt_sync_write(tc->sd,cmd,sdslen(cmd),1000) == -1) { sdsfree(cmd); return sdscatprintf(sdsempty(),"-Writing to master: %s", strerror(errno)); } sdsfree(cmd); va_end(ap); } if (flags & SYNC_CMD_READ) { ssize_t nread; char buf[256]; nread = rmt_sync_readline(tc->sd,buf,sizeof(buf),1000); if (nread == -1) { return sdscatprintf(sdsempty(),"-Reading from master: %s", strerror(errno)); } rr->repl_lastio = rdata->unixtime; return sdsnew(buf); } return NULL; }
int redis_replication_init(redis_repl *rr); void redis_replication_deinit(redis_repl *rr); int redis_node_init(redis_node *rnode, const char *addr, redis_group *rgroup); void redis_node_deinit(redis_node *rnode); void redis_group_deinit(redis_group *rgroup); int redis_rdb_init(redis_rdb *rdb, const char *addr, int type); void redis_rdb_deinit(redis_rdb *rdb); char *rmt_send_sync_cmd_read_line(int fd, ...); static int rmt_redis_send_cmd(int fd, ...); static int redisRplicationReset(redis_node *srnode); static int rmtSlaveIsInHandshakeState(redis_node *srnode); static int rmtTryPartialResynchronization(redis_node *srnode, int read_reply); static void rmtRedisSlaveReadQueryFromMaster(aeEventLoop *el, int fd, void *privdata, int mask); static void rmtRedisRdbDataPost(redis_node *srnode); static int rmtRedisSlavePrepareOnline(redis_node *srnode); void rmtRedisSlaveOffline(redis_node *srnode); static int rmtRedisSlaveAgainOnline(redis_node *srnode); void rmtReceiveRdbAbort(redis_node *srnode); static void rmtReceiveRdb(aeEventLoop *el, int fd, void *privdata, int mask); static void rmtSyncRedisMaster(aeEventLoop *el, int fd, void *privdata, int mask); int rmtConnectRedisMaster(redis_node *srnode); void redisSlaveReplCorn(redis_node *srnode); int redis_response_check(redis_node *rnode, struct msg *r); static int redis_copy_bulk(struct msg *dst, struct msg *src); void redis_pre_coalesce(struct msg *r); static int redis_append_key(struct msg *r, uint8_t *key, uint32_t keylen); int redis_append_bulk(struct msg *r, uint8_t *str, uint32_t str_len); static void redis_erase_one_head_bulk(struct msg *msg); int redis_reply(struct msg *r); static void redis_post_coalesce_mset(struct msg *request); static void redis_post_coalesce_del(struct msg *request); static void redis_post_coalesce_mget(struct msg *request); void redis_post_coalesce(struct msg *r); sds redis_msg_response_get_bulk_string(struct msg *msg); int redis_msg_append_multi_bulk_len_full(struct msg *msg, uint32_t integer); int redis_msg_append_bulk_full(struct msg *msg, const char *str, uint32_t len); int redis_msg_append_command_full(struct msg * msg, ...); int redis_msg_append_command_full_safe(struct msg * msg, struct array *args); struct array *redis_value_create(uint32_t nelem); void redis_value_destroy(struct array *value); static int redis_rdb_file_read(redis_rdb *rdb, void *buf, size_t len); static uint32_t redis_rdb_file_load_len(redis_rdb *rdb, int *isencoded); static long long redis_rdb_file_load_int(redis_rdb *rdb, int enctype); static sds redis_rdb_file_load_double_str(redis_rdb *rdb); static sds redis_rdb_file_load_lzf_str(redis_rdb *rdb); static sds redis_rdb_file_load_str(redis_rdb *rdb); static struct array *redis_rdb_file_load_value(redis_rdb *rdb, int rdbtype); static int redis_object_type_get_by_rdbtype(int dbtype); void redis_delete_rdb_file(redis_rdb *rdb, int always); int redis_parse_rdb_file(redis_node *srnode, int mbuf_count_one_time); int redis_parse_rdb_time(aeEventLoop *el, long long id, void *privdata); void redis_parse_rdb(aeEventLoop *el, int fd, void *privdata, int mask); int redis_load_aof_file(redis_node *srnode, char *aof_file); static unsigned int clusterKeyHashSlot(char *key, int keylen); static void cluster_nodes_swap_tc(dict *nodes_f, dict *nodes_t); static ssize_t rmt_redis_sync_read_string(int fd, char *ptr, long long timeout); static int cluster_update_route(redis_group *rgroup); int redis_cluster_init_from_addrs(redis_group *rgroup, const char *addrs); int redis_cluster_init_from_conf(redis_group *rgroup, conf_pool *cp); int redis_rdb_file_init_from_conf(redis_group *rgroup, conf_pool *cp); int redis_aof_file_init_from_conf(redis_group *rgroup, conf_pool *cp);
2d4b52dc5392f4aaec4a4dffcee12f4ed95d94ca7aebf645fd8573655f0922ba
1,245
thenickreynolds
pebblesnake
snake.c
pbl_main
void pbl_main(void *params) { PebbleAppHandlers handlers = { .init_handler = &handle_init, .timer_handler = &handle_timer }; app_event_loop(params, &handlers); }
void draw_rect(GContext *ctx, GPoint topLeft, unsigned short width, unsigned short height); GPoint get_point_from_position(Position *pos); void draw_fruit(GContext *ctx); void draw_snake(GContext *ctx); void draw_border(GContext *ctx); void draw(GContext *ctx); unsigned short random(); void gen_fruit_position(); void copy_position(unsigned short to, unsigned short from); unsigned short is_same_position(Position *a, Position *b); unsigned short is_out_of_bounds(Position *pos); unsigned short is_game_over(); void tick_game(); void init_snake(); void schedule_timer(AppContextRef ctx); void reset_game(); void init_game(AppContextRef ctx); void update_snake_callback(Layer *me, GContext *ctx); void handle_timer(AppContextRef ctx, AppTimerHandle handle, uint32_t cookie); void change_snake_direction(short direction); void handle_up_button_press(ClickRecognizerRef recognizer, Window *window); void handle_down_button_press(ClickRecognizerRef recognizer, Window *window); void handle_select_button_press(ClickRecognizerRef recognizer, Window *window); void click_config_provider(ClickConfig **config, Window *window); void handle_init(AppContextRef ctx);
0f5a1a2d32f213b77bae2d4fbfa51698361322de3a4ac49a8134a3360738971e
176
Rover-Yu
ali_kernel
drivers/ata/ahci.c
*ahci_port_base
static inline void __iomem *ahci_port_base(struct ata_port *ap) { return __ahci_port_base(ap->host, ap->port_no); }
static void ahci_enable_ahci(void __iomem *mmio); static void ahci_restore_initial_config(struct ata_host *host); static unsigned ahci_scr_offset(struct ata_port *ap, unsigned int sc_reg); static int ahci_scr_read(struct ata_link *link, unsigned int sc_reg, u32 *val); static int ahci_scr_write(struct ata_link *link, unsigned int sc_reg, u32 val); static int ahci_stop_engine(struct ata_port *ap); static void ahci_start_engine(struct ata_port *ap); static void ahci_start_fis_rx(struct ata_port *ap); static int ahci_stop_fis_rx(struct ata_port *ap); static void ahci_power_up(struct ata_port *ap); static void ahci_disable_alpm(struct ata_port *ap); static void ahci_power_down(struct ata_port *ap); static void ahci_start_port(struct ata_port *ap); static int ahci_deinit_port(struct ata_port *ap, const char **emsg); static int ahci_reset_controller(struct ata_host *host); static void ahci_sw_activity(struct ata_link *link); static void ahci_sw_activity_blink(unsigned long arg); static void ahci_init_sw_activity(struct ata_link *link); static int ahci_reset_em(struct ata_host *host); static ssize_t ahci_led_show(struct ata_port *ap, char *buf); static ssize_t ahci_activity_store(struct ata_device *dev, enum sw_activity val); static ssize_t ahci_activity_show(struct ata_device *dev, char *buf); static void ahci_init_controller(struct ata_host *host); static void ahci_dev_config(struct ata_device *dev); static unsigned int ahci_dev_classify(struct ata_port *ap); static int ahci_kick_engine(struct ata_port *ap); static int ahci_check_ready(struct ata_link *link); static int ahci_sb600_check_ready(struct ata_link *link); static void ahci_postreset(struct ata_link *link, unsigned int *class); static unsigned int ahci_fill_sg(struct ata_queued_cmd *qc, void *cmd_tbl); static int ahci_pmp_qc_defer(struct ata_queued_cmd *qc); static void ahci_qc_prep(struct ata_queued_cmd *qc); static void ahci_fbs_dec_intr(struct ata_port *ap); static void ahci_error_intr(struct ata_port *ap, u32 irq_stat); static void ahci_port_intr(struct ata_port *ap); static irqreturn_t ahci_interrupt(int irq, void *dev_instance); static unsigned int ahci_qc_issue(struct ata_queued_cmd *qc); static bool ahci_qc_fill_rtf(struct ata_queued_cmd *qc); static void ahci_freeze(struct ata_port *ap); static void ahci_thaw(struct ata_port *ap); static void ahci_error_handler(struct ata_port *ap); static void ahci_post_internal_cmd(struct ata_queued_cmd *qc); static void ahci_enable_fbs(struct ata_port *ap); static void ahci_disable_fbs(struct ata_port *ap); static void ahci_pmp_attach(struct ata_port *ap); static void ahci_pmp_detach(struct ata_port *ap); static int ahci_port_resume(struct ata_port *ap); static int ahci_port_suspend(struct ata_port *ap, pm_message_t mesg); static int ahci_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg); static int ahci_pci_device_resume(struct pci_dev *pdev); static int ahci_port_start(struct ata_port *ap); static void ahci_port_stop(struct ata_port *ap); static int ahci_configure_dma_masks(struct pci_dev *pdev, int using_dac); static void ahci_print_info(struct ata_host *host); static void ahci_p5wdh_workaround(struct ata_host *host); static bool ahci_sb600_enable_64bit(struct pci_dev *pdev); static bool ahci_broken_system_poweroff(struct pci_dev *pdev); static bool ahci_broken_suspend(struct pci_dev *pdev); static bool ahci_broken_online(struct pci_dev *pdev); static void ahci_gtf_filter_workaround(struct ata_host *host); static inline void ahci_gtf_filter_workaround(struct ata_host *host); static int ahci_init_one(struct pci_dev *pdev, const struct pci_device_id *ent); static int __init ahci_init(void); static void __exit ahci_exit(void);
120e50f2711a957be8cfa7e2d8a0ef2f223b7b3f3f03901cbbd13d4648be2646
117
Mustaavalkosta
toolchain_gcc-4.8
gcc/config/sh/sh.c
rtx gen_block_redirect
static rtx gen_block_redirect (rtx jump, int addr, int need_block) { int dead = 0; rtx prev = prev_nonnote_insn (jump); rtx dest; if (prev && NONJUMP_INSN_P (prev) && ! INSN_DELETED_P (prev)) { if (INSN_CODE (prev) == CODE_FOR_indirect_jump_scratch) return prev; if (GET_CODE (PATTERN (prev)) == USE || GET_CODE (PATTERN (prev)) == CLOBBER || get_attr_in_delay_slot (prev) == IN_DELAY_SLOT_YES) prev = jump; else if ((need_block &= ~1) < 0) return prev; else if (recog_memoized (prev) == CODE_FOR_block_branch_redirect) need_block = 0; } if (GET_CODE (PATTERN (jump)) == RETURN) { if (! need_block) return prev; return emit_insn_before (gen_block_branch_redirect (const0_rtx) , jump); } dest = XEXP (SET_SRC (PATTERN (jump)), 0); if (optimize && (INSN_ADDRESSES (INSN_UID (dest)) - addr + (unsigned) 4092 > 4092 + 4098)) { rtx scan; unsigned attempt = 0x7fff, used; int jump_left = flag_expensive_optimizations + 1; for (scan = jump; (scan = PREV_INSN (scan)); ) { enum rtx_code code; if (INSN_DELETED_P (scan)) continue; code = GET_CODE (scan); if (code == CODE_LABEL || code == JUMP_INSN) break; if (code == INSN && GET_CODE (PATTERN (scan)) != USE && GET_CODE (PATTERN (scan)) != CLOBBER && get_attr_in_delay_slot (scan) == IN_DELAY_SLOT_YES) { attempt &= ~regs_used (PATTERN (scan), 0); break; } } for (used = dead = 0, scan = JUMP_LABEL (jump); (scan = NEXT_INSN (scan)); ) { enum rtx_code code; if (INSN_DELETED_P (scan)) continue; code = GET_CODE (scan); if (INSN_P (scan)) { used |= regs_used (PATTERN (scan), 0); if (code == CALL_INSN) used |= regs_used (CALL_INSN_FUNCTION_USAGE (scan), 0); dead |= (used >> 16) & ~used; if (dead & attempt) { dead &= attempt; break; } if (code == JUMP_INSN) { if (jump_left-- && simplejump_p (scan)) scan = JUMP_LABEL (scan); else break; } } } dead &= 0x7fff; } else if (optimize && need_block >= 0) { rtx next = next_active_insn (next_active_insn (dest)); if (next && JUMP_P (next) && GET_CODE (PATTERN (next)) == SET && recog_memoized (next) == CODE_FOR_jump_compact) { dest = JUMP_LABEL (next); if (dest && (INSN_ADDRESSES (INSN_UID (dest)) - addr + (unsigned) 4092 > 4092 + 4098)) gen_block_redirect (next, INSN_ADDRESSES (INSN_UID (next)), -1); } } if (dead) { rtx reg = gen_rtx_REG (SImode, exact_log2 (dead & -dead)); rtx insn = emit_insn_before (gen_indirect_jump_scratch (reg, GEN_INT (unspec_bbr_uid++)), jump); INSN_LOCATION (insn) = INSN_LOCATION (jump); INSN_CODE (insn) = CODE_FOR_indirect_jump_scratch; return insn; } else if (need_block) return emit_insn_before (gen_block_branch_redirect (GEN_INT (unspec_bbr_uid++)), jump); return prev; }
56e7d04e1d5a0e828c5df2b25e74bc519dc77687c5b4b4bd971e40cee7ebd945
3,118
Qihoo360
huststore
hustdb/ha/nginx/src/core/cjson_serialization_base.c
cjson_serialize_double
json_t * cjson_serialize_double(const double * obj_val) { return obj_val ? cJSON_CreateNumber(*obj_val) : NULL; }
void json_init_hooks(json_hooks_t* hooks); void * json_malloc(size_t size); void json_free(void * obj); static char * __load_from_file(const char * path); static json_bool_t __save_to_file(const char * data, const char * path); json_bool_t json_is_array(const json_t * json_val); json_bool_t json_is_object(const json_t * json_val); json_t * json_object(); json_t * json_array(); size_t json_array_size(const json_t * json_val); json_t * json_array_get_item(const json_t * json_val, size_t index); json_bool_t json_array_append_item(json_t * json_val, json_t * item); json_t * json_object_get_field(const json_t * json_val, const char * key); json_bool_t json_object_set_field(json_t * json_val, const char * key, json_t * child); json_t * json_load_from_str(const char * json_val); char * json_dump_to_str(const json_t * json_val); json_t * json_load_from_file(const char * path); json_bool_t json_dump_to_file(const json_t * json_val, const char * path); json_bool_t cjson_copy_to_string(const char * src, json_str_t * des); json_bool_t cjson_set_integer(const json_int_t * src, json_int_t * des); json_bool_t cjson_set_double(const double * src, double * des); json_bool_t cjson_set_string(const json_str_t * src, json_str_t * des); json_bool_t cjson_eq_integer(const json_int_t * src, json_int_t * des); json_bool_t cjson_eq_double(const double * src, double * des); json_bool_t cjson_eq_string(const json_str_t * src, json_str_t * des); void cjson_dispose_integer(json_int_t * obj_val); void cjson_dispose_double(double * obj_val); void cjson_dispose_string(json_str_t * obj_val); json_t * cjson_serialize_integer(const json_int_t * obj_val); json_t * cjson_serialize_string(const json_str_t * obj_val); json_bool_t cjson_deserialize_integer(const json_t * json_val, json_int_t * obj_val); json_bool_t cjson_deserialize_double(const json_t * json_val, double * obj_val); json_bool_t cjson_deserialize_string(const json_t * json_val, json_str_t * obj_val); void cjson_dispose_json_value(json_t * json_val);
6e9751a84bcb28b64a877f05d422b101e1d768ab4ce50951fa95d67b0daa3912
115
MobileCloudNetworking
icnaas
csrc/sync/SyncUtil.c
void SyncNoteErr
extern void SyncNoteErr(const char *msg) { char *s = getenv("CCNS_NOTE_ERR"); int useStdErr = 0; if (s != NULL && s[0] != 0) useStdErr = strtol(s, NULL, 10); if (useStdErr > 0) { fprintf(stderr, "**** error in %s\n", msg); fflush(stderr); } }
ea3878f7f268aba08533414843bb0f4fe295f94b14d6928a3196941092ad4421
287
ChibiOS
ChibiOS
test/mfs/source/test/mfs_test_sequence_001.c
mfs_test_001_005_teardown
static void mfs_test_001_005_teardown(void) { mfsStop(&mfs1); }
static void mfs_test_001_001_setup(void); static void mfs_test_001_001_teardown(void); static void mfs_test_001_001_execute(void); static void mfs_test_001_002_setup(void); static void mfs_test_001_002_teardown(void); static void mfs_test_001_002_execute(void); static void mfs_test_001_003_setup(void); static void mfs_test_001_003_teardown(void); static void mfs_test_001_003_execute(void); static void mfs_test_001_004_setup(void); static void mfs_test_001_004_teardown(void); static void mfs_test_001_004_execute(void); static void mfs_test_001_005_setup(void); static void mfs_test_001_005_execute(void); static void mfs_test_001_006_setup(void); static void mfs_test_001_006_teardown(void); static void mfs_test_001_006_execute(void); static void mfs_test_001_007_setup(void); static void mfs_test_001_007_teardown(void); static void mfs_test_001_007_execute(void);
eebd5ec646ee7ce229136ccce1e95472055d00afee86f36876b85da4ce0316dd
66
GenaSG
ET
src/client/cl_ui.c
LAN_GetPing
tatic void LAN_GetPing( int n, char *buf, int buflen, int *pingtime ) { CL_GetPing( n, buf, buflen, pingtime ); }
tatic void GetClientState( uiClientState_t *state ); oid LAN_LoadCachedServers(); oid LAN_SaveServersToCache(); tatic void LAN_ResetPings( int source ); tatic int LAN_AddServer( int source, const char *name, const char *address ); tatic void LAN_RemoveServer( int source, const char *addr ); tatic int LAN_GetServerCount( int source ); tatic void LAN_GetServerAddressString( int source, int n, char *buf, int buflen ); tatic void LAN_GetServerInfo( int source, int n, char *buf, int buflen ); tatic int LAN_GetServerPing( int source, int n ); tatic serverInfo_t *LAN_GetServerPtr( int source, int n ); tatic int LAN_CompareServers( int source, int sortKey, int sortDir, int s1, int s2 ); tatic int LAN_GetPingQueueCount( void ); tatic void LAN_ClearPing( int n ); tatic void LAN_GetPingInfo( int n, char *buf, int buflen ); tatic void LAN_MarkServerVisible( int source, int n, qboolean visible ); tatic int LAN_ServerIsVisible( int source, int n ); boolean LAN_UpdateVisiblePings( int source ); nt LAN_GetServerStatus( char *serverAddress, char *serverStatus, int maxLen ); boolean LAN_ServerIsInFavoriteList( int source, int n ); tatic void CL_GetGlconfig( glconfig_t *config ); tatic void GetClipboardData( char *buf, int buflen ); oid Key_KeynumToStringBuf( int keynum, char *buf, int buflen ); oid Key_GetBindingBuf( int keynum, char *buf, int buflen ); nt Key_GetCatcher( void ); oid Key_SetCatcher( int catcher ); tatic void CLUI_GetCDKey( char *buf, int buflen ); tatic void CLUI_SetCDKey( char *buf ); tatic int GetConfigString( int index, char *buf, int size ); tatic int FloatAsInt( float f ); nt CL_UISystemCalls( int *args ); oid CL_ShutdownUI( void ); oid CL_InitUI( void ); boolean UI_usesUniqueCDKey(); boolean UI_checkKeyExec( int key ); boolean UI_GameCommand( void );
60e669b883d65d84788bd3e962f7713656acc1f9f81d72b4227d3c2a33d3c36a
116
polaco1782
quake2
src/game/p_hud.c
DeathmatchScoreboardMessage
void DeathmatchScoreboardMessage (edict_t *ent, edict_t *killer) { char entry[1024]; char string[1400]; int stringlength; int i, j, k; int sorted[MAX_CLIENTS]; int sortedscores[MAX_CLIENTS]; int score, total; int picnum; int x, y; gclient_t *cl; edict_t *cl_ent; char *tag; if (ent->is_bot) return; total = 0; for (i=0 ; i<game.maxclients ; i++) { cl_ent = g_edicts + 1 + i; if (!cl_ent->inuse || game.clients[i].resp.spectator) continue; score = game.clients[i].resp.score; for (j=0 ; j<total ; j++) { if (score > sortedscores[j]) break; } for (k=total ; k>j ; k--) { sorted[k] = sorted[k-1]; sortedscores[k] = sortedscores[k-1]; } sorted[j] = i; sortedscores[j] = score; total++; } string[0] = 0; stringlength = strlen(string); if (total > 12) total = 12; for (i=0 ; i<total ; i++) { cl = &game.clients[sorted[i]]; cl_ent = g_edicts + 1 + sorted[i]; picnum = gi.imageindex ("i_fixme"); x = (i>=6) ? 160 : 0; y = 32 + 32 * (i%6); if (cl_ent == ent) tag = "tag1"; else if (cl_ent == killer) tag = "tag2"; else tag = NULL; if (tag) { Com_sprintf (entry, sizeof(entry), "xv %i yv %i picn %s ",x+32, y, tag); j = strlen(entry); if (stringlength + j > 1024) break; strcpy (string + stringlength, entry); stringlength += j; } Com_sprintf (entry, sizeof(entry), "client %i %i %i %i %i %i ", x, y, sorted[i], cl->resp.score, cl->ping, (level.framenum - cl->resp.enterframe)/600); j = strlen(entry); if (stringlength + j > 1024) break; strcpy (string + stringlength, entry); stringlength += j; } gi.WriteByte (svc_layout); gi.WriteString (string); }
void MoveClientToIntermission (edict_t *ent); void BeginIntermission (edict_t *targ); void DeathmatchScoreboard (edict_t *ent); void Cmd_Score_f (edict_t *ent); void HelpComputer (edict_t *ent); void Cmd_Help_f (edict_t *ent); void G_SetStats (edict_t *ent); void G_CheckChaseStats (edict_t *ent); void G_SetSpectatorStats (edict_t *ent);
fce2ee870ae0e76d1ca4539d898ab7962ea309be2d58b4b99be1cc7bbc3dedac
1,723
aceofall
zephyr-iotos
ext/hal/silabs/gecko/emlib/src/em_cmu.c
CMU_HFRCOStartupDelaySet
void CMU_HFRCOStartupDelaySet(uint32_t delay) { EFM_ASSERT(delay <= 31); delay &= _CMU_HFRCOCTRL_SUDELAY_MASK >> _CMU_HFRCOCTRL_SUDELAY_SHIFT; CMU->HFRCOCTRL = (CMU->HFRCOCTRL & ~(_CMU_HFRCOCTRL_SUDELAY_MASK)) | (delay << _CMU_HFRCOCTRL_SUDELAY_SHIFT); }
static uint32_t maxFreqHfle(void); static void setHfLeConfig(uint32_t hfFreq, uint32_t maxLeFreq); static uint32_t getHfLeConfig(void); static uint32_t auxClkGet(void); static uint32_t dbgClkGet(void); static void flashWaitStateControl(uint32_t coreFreq); static void flashWaitStateMax(void); static uint32_t getRegIshUpperVal(uint32_t steadyStateRegIsh); static uint32_t lfClkGet(CMU_Clock_TypeDef lfClkBranch); __STATIC_INLINE void syncReg(uint32_t mask); static uint32_t usbCClkGet(void); CMU_AUXHFRCOBand_TypeDef CMU_AUXHFRCOBandGet(void); void CMU_AUXHFRCOBandSet(CMU_AUXHFRCOBand_TypeDef band); static uint32_t CMU_AUXHFRCODevinfoGet(CMU_AUXHFRCOFreq_TypeDef freq); CMU_AUXHFRCOFreq_TypeDef CMU_AUXHFRCOBandGet(void); void CMU_AUXHFRCOBandSet(CMU_AUXHFRCOFreq_TypeDef setFreq); uint32_t CMU_Calibrate(uint32_t HFCycles, CMU_Osc_TypeDef ref); uint32_t CMU_CalibrateCountGet(void); CMU_ClkDiv_TypeDef CMU_ClockDivGet(CMU_Clock_TypeDef clock); void CMU_ClockDivSet(CMU_Clock_TypeDef clock, CMU_ClkDiv_TypeDef div); void CMU_ClockEnable(CMU_Clock_TypeDef clock, bool enable); uint32_t CMU_ClockFreqGet(CMU_Clock_TypeDef clock); uint32_t CMU_ClockPrescGet(CMU_Clock_TypeDef clock); void CMU_ClockPrescSet(CMU_Clock_TypeDef clock, CMU_ClkPresc_TypeDef presc); CMU_Select_TypeDef CMU_ClockSelectGet(CMU_Clock_TypeDef clock); void CMU_ClockSelectSet(CMU_Clock_TypeDef clock, CMU_Select_TypeDef ref); void CMU_FreezeEnable(bool enable); CMU_HFRCOBand_TypeDef CMU_HFRCOBandGet(void); void CMU_HFRCOBandSet(CMU_HFRCOBand_TypeDef band); static uint32_t CMU_HFRCODevinfoGet(CMU_HFRCOFreq_TypeDef freq); CMU_HFRCOFreq_TypeDef CMU_HFRCOBandGet(void); void CMU_HFRCOBandSet(CMU_HFRCOFreq_TypeDef setFreq); uint32_t CMU_HFRCOStartupDelayGet(void); void CMU_HFXOInit(const CMU_HFXOInit_TypeDef *hfxoInit); uint32_t CMU_LCDClkFDIVGet(void); void CMU_LCDClkFDIVSet(uint32_t div); void CMU_LFXOInit(const CMU_LFXOInit_TypeDef *lfxoInit); void CMU_OscillatorEnable(CMU_Osc_TypeDef osc, bool enable, bool wait); uint32_t CMU_OscillatorTuningGet(CMU_Osc_TypeDef osc); void CMU_OscillatorTuningSet(CMU_Osc_TypeDef osc, uint32_t val); bool CMU_PCNTClockExternalGet(unsigned int instance); void CMU_PCNTClockExternalSet(unsigned int instance, bool external); CMU_USHFRCOBand_TypeDef CMU_USHFRCOBandGet(void); void CMU_USHFRCOBandSet(CMU_USHFRCOBand_TypeDef band);
a8f03adb7476d3e86c555f8dd7f962b11d4ae79b9cdda33038f0649f6c2ce90e
288
jrobhoward
SCADAbase
usr.sbin/newsyslog/newsyslog.c
void expand_globs
static void expand_globs(struct cflist *work_p, struct cflist *glob_p) { int gmatch, gres; size_t i; char *mfname; struct conf_entry *dupent, *ent, *globent; glob_t pglob; struct stat st_fm; STAILQ_FOREACH(globent, glob_p, cf_nextp) { gres = glob(globent->log, GLOB_NOCHECK, NULL, &pglob); if (gres != 0) { warn("cannot expand pattern (%d): %s", gres, globent->log); continue; } if (verbose > 2) printf("\t+ Expanding pattern %s\n", globent->log); for (i = 0; i < pglob.gl_matchc; i++) { mfname = pglob.gl_pathv[i]; gmatch = 0; STAILQ_FOREACH(ent, work_p, cf_nextp) { if (strcmp(mfname, ent->log) == 0) { gmatch++; break; } } if (gmatch) continue; gres = lstat(mfname, &st_fm); if (gres != 0) { warn("Skipping %s - lstat() error", mfname); continue; } if (!S_ISREG(st_fm.st_mode)) { if (verbose > 2) printf("\t+ . skipping %s (!file)\n", mfname); continue; } if (verbose > 2) printf("\t+ . add file %s\n", mfname); dupent = init_entry(mfname, globent); dupent->flags &= ~CE_GLOB; STAILQ_INSERT_TAIL(work_p, dupent, cf_nextp); } globfree(&pglob); if (verbose > 2) printf("\t+ Done with pattern %s\n", globent->log); } }
a816e913f2c017ca208b636aaf34f4688b531148967221a218e57d0c7e895057
1,303
GabrielGanne
vpp-flowtable
src/vnet/bfd/bfd_udp.c
bfd_udp_add_session
vnet_api_error_t bfd_udp_add_session (u32 sw_if_index, u32 desired_min_tx_us, u32 required_min_rx_us, u8 detect_mult, const ip46_address_t *local_addr, const ip46_address_t *peer_addr) { vnet_api_error_t rv = bfd_udp_validate_api_input (sw_if_index, local_addr, peer_addr); if (rv) { return rv; } if (detect_mult < 1) { BFD_ERR ("detect_mult < 1"); return VNET_API_ERROR_INVALID_ARGUMENT; } if (desired_min_tx_us < 1) { BFD_ERR ("desired_min_tx_us < 1"); return VNET_API_ERROR_INVALID_ARGUMENT; } return bfd_udp_add_session_internal (&bfd_udp_main, sw_if_index, desired_min_tx_us, required_min_rx_us, detect_mult, local_addr, peer_addr); }
static void bfd_rpc_update_session_cb (const bfd_rpc_update_t *a); static void bfd_rpc_update_session (u32 bs_idx, const bfd_pkt_t *pkt); static bfd_udp_error_t bfd_udp6_scan (vlib_main_t *vm, vlib_buffer_t *b); static clib_error_t *bfd_udp_init (vlib_main_t *vm);
b48a53d2176393179e209e2dd1b0bbbe6bca1ee5b8fd213029f25f724404eca9
902
juddy
edcde
programs/dtsr/dtsrkdump.c
main
int main (int argc, char *argv[]) { int i; int oops; int dotcount; long keycount; long total; char *ptr; int do_objkeys = FALSE; int do_wordkeys = FALSE; char dbpath[2048]; char rcs_revision [8]; char dbname[12]; time_t now; double percent = 0.0; int listing_most_words = FALSE; static char *word_labels[6] = { "Short Stems = %8ld\n", "Short Words = %8ld\n", "Long Stems = %8ld\n", "Long Words = %8ld\n", "Huge Stems = %8ld\n", "Huge Words = %8ld\n" }; aa_argv0 = argv[0]; time (&now); sscanf ("$Revision: /main/3 $", "%*s %s", rcs_revision); setlocale (LC_ALL, ""); dtsearch_catd = catopen (FNAME_DTSRCAT, 0); strftime (buf, sizeof (buf), "%m/%d/%Y, %I:%M %p", localtime (&now)); printf (catgets(dtsearch_catd, MS_dtsrkdump, 3, "%s %s, engine %s. %s.\n"), aa_argv0, rcs_revision, AUSAPI_VERSION, buf); if (argc <= 1) { PRINT_USAGE: printf (catgets(dtsearch_catd, MS_dtsrkdump, 4, "\nUSAGE: %s -o|w|ow [-v] [-t<N> | -p<N>] dbname\n" " Reads DtSearch key files and prints summary report.\n" " -o Keys examined are OBJECT record keys.\n" " -w Keys examined are inverted index WORDS.\n" " -v VERBOSE mode, lists every key.\n" " -t<N> Threshold. Sets w and v options, and lists only words\n" " with >= <N> addresses. All words will be listed if <N> = 1.\n" " -p<N> Another threshold. Same as -t except <N> is percent\n" " of the entire database (<N> may include a decimal point).\n" " For example -p99.9 prints out every word that occurs\n" " in 99.9%% or more of the records--an excellent way to find\n" " candidates for the stop list.\n" " If w and v are set without threshold, default is -t%d.\n" " <dbname> 1 - 8 character database name with optional path prefix.\n") ,aa_argv0 ,MIN_THRESHOLD ); DtSearchExit (2); } else { for (;;) { --argc; ++argv; if (argc <= 0) break; ptr = argv[0]; if (*ptr != '-') break; while (*(++ptr) != 0) { switch (*ptr) { case 'o': do_objkeys = TRUE; break; case 'w': do_wordkeys = TRUE; break; case 'v': do_verbose = TRUE; break; case 'p': do_verbose = TRUE; do_wordkeys = TRUE; percent = atof (ptr + 1); if (percent <= 0.0 || percent > 100.0) { fprintf (stderr, catgets (dtsearch_catd, MS_dtsrkdump, 5, "%s Invalid percent value %lf.\a\n"), PROGNAME"195", percent); goto PRINT_USAGE; } ptr[1] = 0; break; case 't': do_verbose = TRUE; do_wordkeys = TRUE; if ((min_threshold = atol (ptr + 1)) <= 0L) { fprintf (stderr, catgets (dtsearch_catd, MS_dtsrkdump, 53, "%s Invalid threshold value.\a\n"), PROGNAME"198"); goto PRINT_USAGE; } ptr[1] = 0; break; default: fprintf (stderr, catgets (dtsearch_catd, MS_dtsrkdump, 55, "%s Unknown command line argument '%c'.\a\n"), PROGNAME"278", *ptr); goto PRINT_USAGE; } } } } oops = FALSE; if (argc <= 0) { printf (catgets (dtsearch_catd, MS_dtsrkdump, 56, "%s Missing required database name.\a\n"), PROGNAME"267"); oops = TRUE; } if (!do_wordkeys && !do_objkeys) { printf (catgets (dtsearch_catd, MS_dtsrkdump, 57, "%s Either -o or -w must be specified.\a\n"), PROGNAME"271"); oops = TRUE; } if (oops) goto PRINT_USAGE; strncpy (dbpath, argv[0], sizeof (dbpath)); dbpath[sizeof (dbpath) - 1] = 0; for (ptr = dbpath + strlen (dbpath) - 1; ptr >= dbpath; ptr--) if (!isalnum (*ptr)) { ptr++; break; } if (ptr < dbpath) ptr = dbpath; i = strlen (ptr); if (i < 1 || i > 8) { fprintf (stderr, catgets (dtsearch_catd, MS_dtsrkdump, 58, "%s Invalid database name '%s'.\a\n"), PROGNAME"297", ptr); goto PRINT_USAGE; } strcpy (dbname, ptr); *ptr = 0; db_oflag = O_RDONLY; if (!austext_dopen (dbname, dbpath, NULL, 0, &dbrec)) { fprintf (stderr, "%s\n", DtSearchGetMessages()); DtSearchExit (3); } maxdba = dbrec.or_maxdba; printf (catgets(dtsearch_catd, MS_dtsrkdump, 60, "%s: '%s' reccount=%ld maxdba=%ld recslots=%hd minw=%hd maxw=%hd\n"), aa_argv0, dbname, dbrec.or_reccount, dbrec.or_maxdba, dbrec.or_recslots, dbrec.or_minwordsz, dbrec.or_maxwordsz); if (percent > 0.0) min_threshold = (long) ((float) percent * (float) dbrec.or_reccount / 100.0); if (min_threshold > dbrec.or_reccount) min_threshold = dbrec.or_reccount; if (do_wordkeys && do_verbose) { if (min_threshold > 1 && min_threshold < dbrec.or_reccount) { printf (catgets(dtsearch_catd, MS_dtsrkdump, 70, "%s Will only list words occurring " "in %ld or more records.\n"), aa_argv0, min_threshold); listing_most_words = (float) min_threshold / (float) dbrec.or_reccount > .90; } else { printf (catgets(dtsearch_catd, MS_dtsrkdump, 80, "%s: Listing all words in database.\n"), aa_argv0); listing_most_words = TRUE; } } if (do_objkeys) { counters = austext_malloc (258 * sizeof(long), PROGNAME"113", NULL); memset (counters, 0, 258 * sizeof(long)); dotcount = 0; keycount = 0; KEYFRST (PROGNAME"111", OR_OBJKEY, 0); while (db_status == S_OKAY) { KEYREAD (PROGNAME"288", buf); (counters[buf[0]])++; CRGET (PROGNAME"251", &dba, 0); if (maxdba < (dba & 0xffffff)) maxdba = dba; if (do_verbose) { i = 0; putchar ('\"'); for (ptr = buf; *ptr != 0; ptr++) { if (*ptr < 32 | *ptr >= 127) { putchar ('.'); i++; } else { putchar (*ptr); i++; } } printf ("\" "); while (i++ < DtSrMAX_DB_KEYSIZE) putchar (' '); printf (catgets(dtsearch_catd, MS_dtsrkdump, 100, "dba x%08lx, %6ld\n"), dba, dba); } else { if (++keycount % KEYS_PER_DOT == 0) { putchar ('.'); if (++dotcount % 10 == 0) putchar (' '); if (dotcount % 50 == 0) { putchar ('\n'); dotcount = 0; } fflush (stdout); } } KEYNEXT (PROGNAME"291", OR_OBJKEY, 0); } if (dotcount) putchar ('\n'); if (dbpath[0] == 0) buf[0] = 0; else sprintf (buf, catgets(dtsearch_catd, MS_dtsrkdump, 110, " in %s"), dbpath); printf (catgets(dtsearch_catd, MS_dtsrkdump, 120, "Object Summary for '%s'%s:\n"), dbname, buf); puts (catgets(dtsearch_catd, MS_dtsrkdump, 130, "Object Count by Keytypes:")); total = 0L; for (i = 0; i < 256; i++) { if (counters[i] > 0L) { total += counters[i]; if (i > 32 && i < 127) printf (" '%c' %6ld\n", i, counters[i]); else printf (" x%02x %6ld\n", i, counters[i]); } } printf (catgets(dtsearch_catd, MS_dtsrkdump, 160, "TOTAL Objects Count = %ld\n"), total); printf (catgets(dtsearch_catd, MS_dtsrkdump, 170, "Largest Object DBA = %ld\n"), maxdba); free (counters); } if (do_wordkeys) { if (listing_most_words) printf (catgets(dtsearch_catd, MS_dtsrkdump, 180, "%s: * Words marked with asterisk occur in every record.\n"), aa_argv0); counters = austext_malloc (8 * sizeof (long), PROGNAME"113", NULL); memset (counters, 0, 6 * sizeof(long)); count_words (0); count_words (2); count_words (4); if (do_objkeys) putchar ('\n'); if (dbpath[0] == 0) buf[0] = 0; else sprintf (buf, catgets(dtsearch_catd, MS_dtsrkdump, 110, " in %s"), dbpath); printf (catgets(dtsearch_catd, MS_dtsrkdump, 200, "Words Summary for '%s'%s:\n"), dbname, buf); total = 0L; for (i = 0; i < 6; i++) { printf (word_labels[i], counters[i]); total += counters[i]; } printf (catgets(dtsearch_catd, MS_dtsrkdump, 210, "TOTAL Words Count = %ld\n"), total); free (counters); } DtSearchExit (0); }
void count_words (int index);
3cd91d9c1cd7bb7e13c8f544dd470f2777d06c49cf1dec4cbd0ac4a2adc60949
8,052
durandj
devkitadv
insight-5.3/gdb/dwarf2read.c
void parse_macro_definition
static void parse_macro_definition (struct macro_source_file *file, int line, const char *body) { const char *p; for (p = body; *p; p++) if (*p == ' ' || *p == '(') break; if (*p == ' ' || *p == '\0') { int name_len = p - body; char *name = copy_string (body, name_len); const char *replacement; if (*p == ' ') replacement = body + name_len + 1; else { complain (&dwarf2_macro_malformed_definition, body); replacement = body + name_len; } macro_define_object (file, line, name, replacement); xfree (name); } else if (*p == '(') { char *name = copy_string (body, p - body); int argc = 0; int argv_size = 1; char **argv = xmalloc (argv_size * sizeof (*argv)); p++; p = consume_improper_spaces (p, body); while (*p && *p != ')') { const char *arg_start = p; while (*p && *p != ',' && *p != ')' && *p != ' ') p++; if (! *p || p == arg_start) complain (&dwarf2_macro_malformed_definition, body); else { if (argc >= argv_size) { argv_size *= 2; argv = xrealloc (argv, argv_size * sizeof (*argv)); } argv[argc++] = copy_string (arg_start, p - arg_start); } p = consume_improper_spaces (p, body); if (*p == ',') { p++; p = consume_improper_spaces (p, body); } } if (*p == ')') { p++; if (*p == ' ') macro_define_function (file, line, name, argc, (const char **) argv, p + 1); else if (*p == '\0') { complain (&dwarf2_macro_malformed_definition, body); macro_define_function (file, line, name, argc, (const char **) argv, p); } else complain (&dwarf2_macro_malformed_definition, body); } else complain (&dwarf2_macro_malformed_definition, body); xfree (name); { int i; for (i = 0; i < argc; i++) xfree (argv[i]); } xfree (argv); } else complain (&dwarf2_macro_malformed_definition, body); }
bf4138cf96e5c380fc92a4fa6a0e6b4bd11385fb80290ea16683c4bba93d6b8d
2,668
easion
os_sdk
jwm-2.0.1/src/border.c
DestroyBorders
void DestroyBorders() { }
void InitializeBorders(); void StartupBorders(); void ShutdownBorders(); int GetBorderIconSize(); BorderActionType GetBorderActionType(const ClientNode *np, int x, int y); void DrawBorder(const ClientNode *np, const XExposeEvent *expose); void DrawBorderHelper(const ClientNode *np, int drawIcon); int GetButtonCount(const ClientNode *np); void DrawBorderButtons(const ClientNode *np, Pixmap canvas, GC gc); void ExposeCurrentDesktop(); void SetBorderWidth(const char *str); void SetTitleHeight(const char *str);
f6cd21b8c940d49b8445e4a2578e6b2ef8775fc2dc1ff054870753f4f58fd7cb
26
retrodeluxe
FUZIX
Kernel/platform-rc2014/devtty.c
quart_intr
static uint8_t quart_intr(uint8_t minor) { uint8_t r = in16(QUARTPORT + QUARTREG(ISR1)); if (r & 0x02) { r = in16(QUARTPORT + QUARTREG(RHRA)); tty_inproc(minor, r); } if (r & 0x20) { r = in16(QUARTPORT + QUARTREG(RHRB)); if (minor + 1 <= NUM_DEV_TTY) tty_inproc(minor + 1 , r); } r = in16(QUARTPORT + QUARTREG(ISR2)); if (r & 0x02) { r = in16(QUARTPORT + QUARTREG(RHRC)); if (minor + 2 <= NUM_DEV_TTY) tty_inproc(minor + 2 , r); } if (r & 0x20) { r = in16(QUARTPORT + QUARTREG(RHRD)); if (minor + 3 <= NUM_DEV_TTY) tty_inproc(minor + 3, r); } if (quart_timer && (r & 0x10)) { in16(QUARTPORT + QUARTREG(STC2)); timer_interrupt(); } return 4; }
void tty_setup(uint_fast8_t minor, uint_fast8_t flags); int tty_carrier(uint_fast8_t minor); void tty_pollirq(void); void tty_putc(uint_fast8_t minor, uint_fast8_t c); void tty_sleeping(uint_fast8_t minor); ttyready_t tty_writeready(uint_fast8_t minor); void tty_data_consumed(uint_fast8_t minor); void kputchar(char c); int rctty_open(uint_fast8_t minor, uint16_t flag); static uint8_t acia_intr(uint8_t minor); static void acia_setup(uint8_t minor); static uint8_t acia_writeready(uint_fast8_t minor); static void acia_putc(uint_fast8_t minor, uint_fast8_t c); static uint8_t carrier_unwired(uint_fast8_t minor); static uint8_t sio_intrb(uint_fast8_t minor); static uint8_t sio_intr(uint_fast8_t minor); static ttyready_t sio_writeready(uint_fast8_t minor); static void sio_putc(uint_fast8_t minor, uint_fast8_t c); static void sio_setup(uint_fast8_t minor); static uint8_t sio_carrier(uint_fast8_t minor); static uint8_t ns16x50_intr(uint_fast8_t minor); static ttyready_t ns16x50_writeready(uint_fast8_t minor); static void ns16x50_putc(uint_fast8_t minor, uint_fast8_t c); static void ns16x50_setup(uint_fast8_t minor); static uint8_t ns16x50_carrier(uint_fast8_t minor); static uint8_t asci_intr0(uint_fast8_t minor); static uint8_t asci_intr1(uint_fast8_t minor); ttyready_t asci_writeready0(uint_fast8_t minor); ttyready_t asci_writeready1(uint_fast8_t minor); static void asci_putc0(uint_fast8_t minor, uint_fast8_t c); static void asci_putc1(uint_fast8_t minor, uint_fast8_t c); static void asci_setup(uint_fast8_t minor); static void quart_setup(uint8_t minor); static uint8_t quart_writeready(uint_fast8_t minor); static void quart_putc(uint_fast8_t minor, uint_fast8_t c); static uint8_t tms_intr(uint8_t minor); static void tms_setup(uint8_t minor); static uint8_t tms_writeready(uint_fast8_t minor); static void tms_setoutput(uint_fast8_t minor); static void tms_putc(uint_fast8_t minor, uint_fast8_t c); void do_conswitch(uint8_t c); void ps2kbd_conswitch(uint8_t console); uint8_t register_uart(uint16_t port, struct uart *ops); void insert_uart(uint16_t port, struct uart *ops); void display_uarts(void); int rctty_ioctl(uint8_t minor, uarg_t arg, char *ptr);
b7611fba6020a2935c98fabd0614b9c6c1daea60351757061ddda5a6a1000497
747
gatieme
LDD-LinuxDeviceDrivers
books/fengguojin/src/2synchronous/2-1spinlock/spin/spinlock.c
*×¢ÏúÉ豸Çý¶¯*/ unregister_chrdev
*×¢ÏúÉ豸Çý¶¯*/ unregister_chrdev(MAJOR_NUM, "chardev"); } module_init(simple_init); module_exit(simple_exit);
static int simple_open(struct inode *inode, struct file *filp); t inode *inode, struct file *filp); ct file *filp, char *buf, size_t len, loff_t*off); uct file *filp, const char *buf, size_t len,loff_t *off); oid);
7c6057cb1b902f775443fe77e30664f1975da0ef1d405fb42115e661bc2dd9be
129
alishakiba
libflame
src/lapack/inv/tri/un/flamec/FLA_Trinv_un_opt_var1.c
FLA_Trinv_un_ops_var1
FLA_Error FLA_Trinv_un_ops_var1( int mn_A, float* buff_A, int rs_A, int cs_A ) { float alpha11_m1; int i; for ( i = 0; i < mn_A; ++i ) { float* A00 = buff_A + (0 )*cs_A + (0 )*rs_A; float* a01 = buff_A + (i )*cs_A + (0 )*rs_A; float* alpha11 = buff_A + (i )*cs_A + (i )*rs_A; int mn_behind = i; bl1_strmv( BLIS1_UPPER_TRIANGULAR, BLIS1_NO_TRANSPOSE, BLIS1_NONUNIT_DIAG, mn_behind, A00, rs_A, cs_A, a01, rs_A ); bl1_sneg2( alpha11, &alpha11_m1 ); bl1_sinvscalv( BLIS1_NO_CONJUGATE, mn_behind, &alpha11_m1, a01, rs_A ); bl1_sinverts( BLIS1_NO_CONJUGATE, alpha11 ); } return FLA_SUCCESS; }
FLA_Error FLA_Trinv_un_opt_var1( FLA_Obj A );
230fbcaa3609c8f86e5b04bd63333238caa24a8c68d319873e6a9984bdae72ce
904
Drusyc
shell
src/readcmd.c
read_word
atic void read_word(char ** cur, char ** cur_buf) { while(1) { char c = **cur; switch (c) { case '\0': case ' ': case '\t': case '<': case '>': case '|': **cur_buf = '\0'; return; case '\'': read_single_quote(cur, cur_buf); break; case '"': read_double_quote(cur, cur_buf); break; case '\\': SKIP_CHAR; READ_CHAR; break; default: READ_CHAR; break; } } } /
atic void memory_error(void); atic void *xmalloc(size_t size); atic void *xrealloc(void *ptr, size_t size); atic char *readline(char *prompt); atic void read_single_quote(char ** cur, char ** cur_buf); atic void read_double_quote(char ** cur, char ** cur_buf); atic char **split_in_words(char *line); atic void freeseq(char ***seq); atic void freecmd(struct cmdline *s); ruct cmdline *readcmd(char *prompt);
b4cab62913d141d969e0b87d0daaf453add4b8cc862077aa8453e948539a279f
417
ApisSys
linux-analogdevicesinc-ap6
ECE695-Spring17/t3-scheduler/linux-4.10.6/drivers/rtc/rtc-tegra.c
tegra_rtc_probe
static int __init tegra_rtc_probe(struct platform_device *pdev) { struct tegra_rtc_info *info; struct resource *res; int ret; info = devm_kzalloc(&pdev->dev, sizeof(struct tegra_rtc_info), GFP_KERNEL); if (!info) return -ENOMEM; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); info->rtc_base = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(info->rtc_base)) return PTR_ERR(info->rtc_base); info->tegra_rtc_irq = platform_get_irq(pdev, 0); if (info->tegra_rtc_irq <= 0) return -EBUSY; info->pdev = pdev; spin_lock_init(&info->tegra_rtc_lock); platform_set_drvdata(pdev, info); writel(0, info->rtc_base + TEGRA_RTC_REG_SECONDS_ALARM0); writel(0xffffffff, info->rtc_base + TEGRA_RTC_REG_INTR_STATUS); writel(0, info->rtc_base + TEGRA_RTC_REG_INTR_MASK); device_init_wakeup(&pdev->dev, 1); info->rtc_dev = devm_rtc_device_register(&pdev->dev, dev_name(&pdev->dev), &tegra_rtc_ops, THIS_MODULE); if (IS_ERR(info->rtc_dev)) { ret = PTR_ERR(info->rtc_dev); dev_err(&pdev->dev, "Unable to register device (err=%d).\n", ret); return ret; } ret = devm_request_irq(&pdev->dev, info->tegra_rtc_irq, tegra_rtc_irq_handler, IRQF_TRIGGER_HIGH, dev_name(&pdev->dev), &pdev->dev); if (ret) { dev_err(&pdev->dev, "Unable to request interrupt for device (err=%d).\n", ret); return ret; } dev_notice(&pdev->dev, "Tegra internal Real Time Clock\n"); return 0; }
static inline u32 tegra_rtc_check_busy(struct tegra_rtc_info *info); static int tegra_rtc_wait_while_busy(struct device *dev); static int tegra_rtc_read_time(struct device *dev, struct rtc_time *tm); static int tegra_rtc_set_time(struct device *dev, struct rtc_time *tm); static int tegra_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm); static int tegra_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled); static int tegra_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm); static int tegra_rtc_proc(struct device *dev, struct seq_file *seq); static irqreturn_t tegra_rtc_irq_handler(int irq, void *data); static int tegra_rtc_suspend(struct device *dev); static int tegra_rtc_resume(struct device *dev); static void tegra_rtc_shutdown(struct platform_device *pdev);
b34820ee006332a1c6e20e50b415be458488699fd402f61d95a88169dd3143ac
1,434
pedia
moosefs
mfsmaster/filesystem.c
fs_loadnode
int fs_loadnode(FILE *fd) { uint8_t unodebuff[4+1+2+4+4+4+4+4+4+8+4+2+8*MAX_CHUNKS_PER_FILE+4*65536+4]; const uint8_t *ptr; uint8_t type; uint32_t indx,pleng,ch,sessionids,sessionid; fsnode *p; sessionidrec *sessionidptr; uint32_t nodepos; #ifndef METARESTORE statsrecord *sr; #endif type = fgetc(fd); if (type==0) { return 1; } p = malloc(sizeof(fsnode)); passert(p); p->type = type; switch (type) { case TYPE_DIRECTORY: case TYPE_FIFO: case TYPE_SOCKET: if (fread(unodebuff,1,4+1+2+4+4+4+4+4+4,fd)!=4+1+2+4+4+4+4+4+4) { mfs_errlog(LOG_ERR,"loading node: read error"); free(p); return -1; } break; case TYPE_BLOCKDEV: case TYPE_CHARDEV: case TYPE_SYMLINK: if (fread(unodebuff,1,4+1+2+4+4+4+4+4+4+4,fd)!=4+1+2+4+4+4+4+4+4+4) { mfs_errlog(LOG_ERR,"loading node: read error"); free(p); return -1; } break; case TYPE_FILE: case TYPE_TRASH: case TYPE_RESERVED: if (fread(unodebuff,1,4+1+2+4+4+4+4+4+4+8+4+2,fd)!=4+1+2+4+4+4+4+4+4+8+4+2) { mfs_errlog(LOG_ERR,"loading node: read error"); free(p); return -1; } break; default: mfs_arg_syslog(LOG_ERR,"loading node: unrecognized node type: %c",type); free(p); return -1; } ptr = unodebuff; p->id = get32bit(&ptr); p->goal = get8bit(&ptr); p->mode = get16bit(&ptr); p->uid = get32bit(&ptr); p->gid = get32bit(&ptr); p->atime = get32bit(&ptr); p->mtime = get32bit(&ptr); p->ctime = get32bit(&ptr); p->trashtime = get32bit(&ptr); switch (type) { case TYPE_DIRECTORY: #ifndef METARESTORE sr = malloc(sizeof(statsrecord)); passert(sr); memset(sr,0,sizeof(statsrecord)); p->data.ddata.stats = sr; p->data.ddata.quota = NULL; #endif p->data.ddata.children = NULL; p->data.ddata.nlink = 2; p->data.ddata.elements = 0; case TYPE_SOCKET: case TYPE_FIFO: break; case TYPE_BLOCKDEV: case TYPE_CHARDEV: p->data.rdev = get32bit(&ptr); break; case TYPE_SYMLINK: pleng = get32bit(&ptr); p->data.sdata.pleng = pleng; if (pleng>0) { p->data.sdata.path = malloc(pleng); passert(p->data.sdata.path); if (fread(p->data.sdata.path,1,pleng,fd)!=pleng) { mfs_errlog(LOG_ERR,"loading node: read error"); free(p->data.sdata.path); free(p); return -1; } } else { p->data.sdata.path = NULL; } break; case TYPE_FILE: case TYPE_TRASH: case TYPE_RESERVED: p->data.fdata.length = get64bit(&ptr); ch = get32bit(&ptr); p->data.fdata.chunks = ch; sessionids = get16bit(&ptr); if (ch>0) { p->data.fdata.chunktab = malloc(sizeof(uint64_t)*ch); passert(p->data.fdata.chunktab); } else { p->data.fdata.chunktab = NULL; } if (fread((uint8_t*)ptr,1,8*ch+4*sessionids,fd)!=8*ch+4*sessionids) { mfs_errlog(LOG_ERR,"loading node: read error"); if (p->data.fdata.chunktab) { free(p->data.fdata.chunktab); } free(p); return -1; } for (indx=0 ; indx<ch ; indx++) { p->data.fdata.chunktab[indx] = get64bit(&ptr);; } p->data.fdata.sessionids=NULL; while (sessionids) { sessionid = get32bit(&ptr); sessionidptr = sessionidrec_malloc(); sessionidptr->sessionid = sessionid; sessionidptr->next = p->data.fdata.sessionids; p->data.fdata.sessionids = sessionidptr; #ifndef METARESTORE matocuserv_init_sessions(sessionid,p->id); #endif sessionids--; } } p->parents = NULL; nodepos = NODEHASHPOS(p->id); p->next = nodehash[nodepos]; nodehash[nodepos] = p; fsnodes_used_inode(p->id); nodes++; if (type==TYPE_DIRECTORY) { dirnodes++; } if (type==TYPE_FILE || type==TYPE_TRASH || type==TYPE_RESERVED) { filenodes++; } return 0; }
void fs_stats(uint32_t stats[16]); static inline freenode* freenode_malloc(); static inline void freenode_free(freenode *p); static inline freenode* freenode_malloc(); static inline void freenode_free(freenode* p); static inline sessionidrec* sessionidrec_malloc(); static inline void sessionidrec_free(sessionidrec *p); static inline sessionidrec* sessionidrec_malloc(); static inline void sessionidrec_free(sessionidrec* p); uint32_t fsnodes_get_next_id(); void fsnodes_free_id(uint32_t id,uint32_t ts); uint8_t fs_freeinodes(uint32_t ts,uint32_t freeinodes); void fsnodes_init_freebitmask (void); void fsnodes_used_inode (uint32_t id); static char* fsnodes_escape_name(uint16_t nleng,const uint8_t *name); static inline uint32_t fsnodes_hash(uint32_t parentid,uint16_t nleng,const uint8_t *name); static inline int fsnodes_nameisused(fsnode *node,uint16_t nleng,const uint8_t *name); static inline fsedge* fsnodes_lookup(fsnode *node,uint16_t nleng,const uint8_t *name); static inline fsnode* fsnodes_id_to_node(uint32_t id); static inline int fsnodes_isancestor(fsnode *f,fsnode *p); static inline quotanode* fsnodes_new_quotanode(); static inline void fsnodes_delete_quotanode(quotanode *qn); static inline void fsnodes_check_quotanode(quotanode *qn,uint32_t ts); void fsnodes_check_all_quotas(void); static inline uint8_t fsnodes_test_quota(fsnode *node); static inline void fsnodes_get_stats(fsnode *node,statsrecord *sr); static inline void fsnodes_sub_stats(fsnode *parent,statsrecord *sr); static inline void fsnodes_add_stats(fsnode *parent,statsrecord *sr); static inline void fsnodes_add_sub_stats(fsnode *parent,statsrecord *newsr,statsrecord *prevsr); static inline void fsnodes_remove_edge(uint32_t ts,fsedge *e); static inline void fsnodes_link(uint32_t ts,fsnode *parent,fsnode *child,uint16_t nleng,const uint8_t *name); static inline fsnode* fsnodes_create_node(uint32_t ts,fsnode* node,uint16_t nleng,const uint8_t *name,uint8_t type,uint16_t mode,uint32_t uid,uint32_t gid); static inline uint32_t fsnodes_getpath_size(fsedge *e); static inline void fsnodes_getpath_data(fsedge *e,uint8_t *path,uint32_t size); static inline void fsnodes_getpath(fsedge *e,uint16_t *pleng,uint8_t **path); static inline void fsnodes_fill_attr(fsnode *node,fsnode *parent,uint32_t uid,uint32_t gid,uint32_t auid,uint32_t agid,uint8_t sesflags,uint8_t attr[35]); static inline uint32_t fsnodes_getdetachedsize(fsedge *start); static inline void fsnodes_getdetacheddata(fsedge *start,uint8_t *dbuff); static inline uint32_t fsnodes_getdirsize(fsnode *p,uint8_t withattr); static inline void fsnodes_getdirdata(uint32_t ts,uint32_t rootinode,uint32_t uid,uint32_t gid,uint32_t auid,uint32_t agid,uint8_t sesflags,fsnode *p,uint8_t *dbuff,uint8_t withattr); static inline void fsnodes_checkfile(fsnode *p,uint16_t chunkcount[256]); static inline uint8_t fsnodes_appendchunks(uint32_t ts,fsnode *dstobj,fsnode *srcobj); static inline void fsnodes_changefilegoal(fsnode *obj,uint8_t goal); static inline void fsnodes_change_levelgoal(fsnode *obj,uint8_t level, uint8_t goal); static inline void fsnodes_setlength(fsnode *obj,uint64_t length); static inline void fsnodes_remove_node(uint32_t ts,fsnode *toremove); static inline void fsnodes_unlink(uint32_t ts,fsedge *e); static inline int fsnodes_purge(uint32_t ts,fsnode *p); static inline uint8_t fsnodes_undel(uint32_t ts,fsnode *node); static inline void fsnodes_getgoal_recursive(fsnode *node,uint8_t gmode,uint32_t fgtab[10],uint32_t dgtab[10]); static inline void fsnodes_getlevelgoal_recursive(fsnode *node,uint8_t gmode,uint32_t fgtab[40],uint32_t dgtab[40]); static inline void fsnodes_bst_add(bstnode **n,uint32_t val); static inline uint32_t fsnodes_bst_nodes(bstnode *n); static inline void fsnodes_bst_storedata(bstnode *n,uint8_t **ptr); static inline void fsnodes_bst_free(bstnode *n); static inline void fsnodes_gettrashtime_recursive(fsnode *node,uint8_t gmode,bstnode **bstrootfiles,bstnode **bstrootdirs); static inline void fsnodes_geteattr_recursive(fsnode *node,uint8_t gmode,uint32_t feattrtab[16],uint32_t deattrtab[16]); static inline void fsnodes_setgoal_recursive(fsnode *node,uint32_t ts,uint32_t uid/*,uint8_t quota*/,uint8_t goal,uint8_t smode,uint32_t *sinodes,uint32_t *ncinodes,uint32_t *nsinodes/*,uint32_t *qeinodes*/); static inline void fsnodes_setlevelgoal_recursive(fsnode *node,uint32_t ts,uint32_t uid/*,uint8_t quota*/,uint8_t level,uint8_t goal,uint8_t smode,uint32_t *sinodes,uint32_t *ncinodes,uint32_t *nsinodes/*,uint32_t *qeinodes*/); static inline void fsnodes_settrashtime_recursive(fsnode *node,uint32_t ts,uint32_t uid,uint32_t trashtime,uint8_t smode,uint32_t *sinodes,uint32_t *ncinodes,uint32_t *nsinodes); static inline void fsnodes_seteattr_recursive(fsnode *node,uint32_t ts,uint32_t uid,uint8_t eattr,uint8_t smode,uint32_t *sinodes,uint32_t *ncinodes,uint32_t *nsinodes); static inline void fsnodes_snapshot(uint32_t ts,fsnode *srcnode,fsnode *parentnode,uint32_t nleng,const uint8_t *name); static inline uint8_t fsnodes_snapshot_test(fsnode *origsrcnode,fsnode *srcnode,fsnode *parentnode,uint32_t nleng,const uint8_t *name,uint8_t canoverwrite); static inline int fsnodes_namecheck(uint32_t nleng,const uint8_t *name); static inline int fsnodes_access(fsnode *node,uint32_t uid,uint32_t gid,uint8_t modemask,uint8_t sesflags); static inline int fsnodes_sticky_access(fsnode *parent,fsnode *node,uint32_t uid); uint8_t fs_access(uint32_t ts,uint32_t inode); uint8_t fs_readreserved_size(uint32_t rootinode,uint8_t sesflags,uint32_t *dbuffsize); void fs_readreserved_data(uint32_t rootinode,uint8_t sesflags,uint8_t *dbuff); uint8_t fs_readtrash_size(uint32_t rootinode,uint8_t sesflags,uint32_t *dbuffsize); void fs_readtrash_data(uint32_t rootinode,uint8_t sesflags,uint8_t *dbuff); uint8_t fs_getdetachedattr(uint32_t rootinode,uint8_t sesflags,uint32_t inode,uint8_t attr[35],uint8_t dtype); uint8_t fs_gettrashpath(uint32_t rootinode,uint8_t sesflags,uint32_t inode,uint32_t *pleng,uint8_t **path); uint8_t fs_setpath(uint32_t inode,const uint8_t *path); uint8_t fs_undel(uint32_t ts,uint32_t inode); uint8_t fs_purge(uint32_t ts,uint32_t inode); void fs_info(uint64_t *totalspace,uint64_t *availspace,uint64_t *trspace,uint32_t *trnodes,uint64_t *respace,uint32_t *renodes,uint32_t *inodes,uint32_t *dnodes,uint32_t *fnodes); uint8_t fs_getrootinode(uint32_t *rootinode,const uint8_t *path); void fs_statfs(uint32_t rootinode,uint8_t sesflags,uint64_t *totalspace,uint64_t *availspace,uint64_t *trspace,uint64_t *respace,uint32_t *inodes); uint8_t fs_access(uint32_t rootinode,uint8_t sesflags,uint32_t inode,uint32_t uid,uint32_t gid,int modemask); uint8_t fs_lookup(uint32_t rootinode,uint8_t sesflags,uint32_t parent,uint16_t nleng,const uint8_t *name,uint32_t uid,uint32_t gid,uint32_t auid,uint32_t agid,uint32_t *inode,uint8_t attr[35]); uint8_t fs_getattr(uint32_t rootinode,uint8_t sesflags,uint32_t inode,uint32_t uid,uint32_t gid,uint32_t auid,uint32_t agid,uint8_t attr[35]); uint8_t fs_try_setlength(uint32_t rootinode,uint8_t sesflags,uint32_t inode,uint8_t opened,uint32_t uid,uint32_t gid,uint32_t auid,uint32_t agid,uint64_t length,uint8_t attr[35],uint64_t *chunkid); uint8_t fs_trunc(uint32_t ts,uint32_t inode,uint32_t indx,uint64_t chunkid); uint8_t fs_end_setlength(uint64_t chunkid); uint8_t fs_unlock(uint64_t chunkid); uint8_t fs_do_setlength(uint32_t rootinode,uint8_t sesflags,uint32_t inode,uint32_t uid,uint32_t gid,uint32_t auid,uint32_t agid,uint64_t length,uint8_t attr[35]); uint8_t fs_setattr(uint32_t rootinode,uint8_t sesflags,uint32_t inode,uint32_t uid,uint32_t gid,uint32_t auid,uint32_t agid,uint8_t setmask,uint16_t attrmode,uint32_t attruid,uint32_t attrgid,uint32_t attratime,uint32_t attrmtime,uint8_t attr[35]); uint8_t fs_attr(uint32_t ts,uint32_t inode,uint32_t mode,uint32_t uid,uint32_t gid,uint32_t atime,uint32_t mtime); uint8_t fs_length(uint32_t ts,uint32_t inode,uint64_t length); uint8_t fs_readlink(uint32_t rootinode,uint8_t sesflags,uint32_t inode,uint32_t *pleng,uint8_t **path); uint8_t fs_symlink(uint32_t ts,uint32_t parent,uint32_t nleng,const uint8_t *name,const uint8_t *path,uint32_t uid,uint32_t gid,uint32_t inode); uint8_t fs_mknod(uint32_t rootinode,uint8_t sesflags,uint32_t parent,uint16_t nleng,const uint8_t *name,uint8_t type,uint16_t mode,uint32_t uid,uint32_t gid,uint32_t auid,uint32_t agid,uint32_t rdev,uint32_t *inode,uint8_t attr[35]); uint8_t fs_mkdir(uint32_t rootinode,uint8_t sesflags,uint32_t parent,uint16_t nleng,const uint8_t *name,uint16_t mode,uint32_t uid,uint32_t gid,uint32_t auid,uint32_t agid,uint32_t *inode,uint8_t attr[35]); uint8_t fs_create(uint32_t ts,uint32_t parent,uint32_t nleng,const uint8_t *name,uint8_t type,uint32_t mode,uint32_t uid,uint32_t gid,uint32_t rdev,uint32_t inode); uint8_t fs_unlink(uint32_t rootinode,uint8_t sesflags,uint32_t parent,uint16_t nleng,const uint8_t *name,uint32_t uid,uint32_t gid); uint8_t fs_rmdir(uint32_t rootinode,uint8_t sesflags,uint32_t parent,uint16_t nleng,const uint8_t *name,uint32_t uid,uint32_t gid); uint8_t fs_unlink(uint32_t ts,uint32_t parent,uint32_t nleng,const uint8_t *name,uint32_t inode); uint8_t fs_move(uint32_t ts,uint32_t parent_src,uint32_t nleng_src,const uint8_t *name_src,uint32_t parent_dst,uint32_t nleng_dst,const uint8_t *name_dst,uint32_t inode); uint8_t fs_link(uint32_t ts,uint32_t inode_src,uint32_t parent_dst,uint32_t nleng_dst,uint8_t *name_dst); uint8_t fs_snapshot(uint32_t ts,uint32_t inode_src,uint32_t parent_dst,uint16_t nleng_dst,uint8_t *name_dst,uint8_t canoverwrite); uint8_t fs_append(uint32_t ts,uint32_t inode,uint32_t inode_src); uint8_t fs_readdir_size(uint32_t rootinode,uint8_t sesflags,uint32_t inode,uint32_t uid,uint32_t gid,uint8_t flags,void **dnode,uint32_t *dbuffsize); void fs_readdir_data(uint32_t rootinode,uint8_t sesflags,uint32_t uid,uint32_t gid,uint32_t auid,uint32_t agid,uint8_t flags,void *dnode,uint8_t *dbuff); uint8_t fs_checkfile(uint32_t rootinode,uint8_t sesflags,uint32_t inode,uint16_t chunkcount[256]); uint8_t fs_opencheck(uint32_t rootinode,uint8_t sesflags,uint32_t inode,uint32_t uid,uint32_t gid,uint32_t auid,uint32_t agid,uint8_t flags,uint8_t attr[35]); uint8_t fs_aquire(uint32_t inode,uint32_t sessionid); uint8_t fs_release(uint32_t inode,uint32_t sessionid); uint32_t fs_newsessionid(void); uint8_t fs_session(uint32_t sessionid); uint8_t fs_readchunk(uint32_t inode,uint32_t indx,uint64_t *chunkid,uint64_t *length); uint8_t fs_writechunk(uint32_t inode,uint32_t indx,uint64_t *chunkid,uint64_t *length,uint8_t *opflag); uint8_t fs_write(uint32_t ts,uint32_t inode,uint32_t indx,uint8_t opflag,uint64_t chunkid); uint8_t fs_writeend(uint32_t inode,uint64_t length,uint64_t chunkid); void fs_incversion(uint64_t chunkid); uint8_t fs_incversion(uint64_t chunkid); uint8_t fs_repair(uint32_t rootinode,uint8_t sesflags,uint32_t inode,uint32_t uid,uint32_t gid,uint32_t *notchanged,uint32_t *erased,uint32_t *repaired); uint8_t fs_repair(uint32_t ts,uint32_t inode,uint32_t indx,uint32_t nversion); uint8_t fs_getgoal(uint32_t rootinode,uint8_t sesflags,uint32_t inode,uint8_t gmode,uint32_t fgtab[10],uint32_t dgtab[10]); uint8_t fs_getlevelgoal(uint32_t rootinode,uint8_t sesflags,uint32_t inode,uint8_t gmode,uint32_t fgtab[40],uint32_t dgtab[40]); uint8_t fs_gettrashtime_prepare(uint32_t rootinode,uint8_t sesflags,uint32_t inode,uint8_t gmode,void **fptr,void **dptr,uint32_t *fnodes,uint32_t *dnodes); void fs_gettrashtime_store(void *fptr,void *dptr,uint8_t *buff); uint8_t fs_geteattr(uint32_t rootinode,uint8_t sesflags,uint32_t inode,uint8_t gmode,uint32_t feattrtab[16],uint32_t deattrtab[16]); uint8_t fs_setgoal(uint32_t ts,uint32_t inode,uint32_t uid,uint8_t goal,uint8_t smode,uint32_t sinodes,uint32_t ncinodes,uint32_t nsinodes/*,uint32_t qeinodes*/); uint8_t fs_setlevelgoal(uint32_t ts,uint32_t inode,uint32_t uid,uint8_t level,uint8_t goal,uint8_t smode,uint32_t sinodes,uint32_t ncinodes,uint32_t nsinodes/*,uint32_t qeinodes*/); uint8_t fs_settrashtime(uint32_t ts,uint32_t inode,uint32_t uid,uint32_t trashtime,uint8_t smode,uint32_t sinodes,uint32_t ncinodes,uint32_t nsinodes); uint8_t fs_seteattr(uint32_t ts,uint32_t inode,uint32_t uid,uint8_t eattr,uint8_t smode,uint32_t sinodes,uint32_t ncinodes,uint32_t nsinodes); uint8_t fs_quotacontrol(uint32_t rootinode,uint8_t sesflags,uint32_t inode,uint8_t delflag,uint8_t *flags,uint32_t *sinodes,uint64_t *slength,uint64_t *ssize,uint64_t *srealsize,uint32_t *hinodes,uint64_t *hlength,uint64_t *hsize,uint64_t *hrealsize,uint32_t *curinodes,uint64_t *curlength,uint64_t *cursize,uint64_t *currealsize); uint32_t fs_getquotainfo_size(); void fs_getquotainfo_data(uint8_t * buff); uint32_t fs_getdirpath_size(uint32_t inode); void fs_getdirpath_data(uint32_t inode,uint8_t *buff,uint32_t size); uint8_t fs_get_dir_stats(uint32_t rootinode,uint8_t sesflags,uint32_t inode,uint32_t *inodes,uint32_t *dirs,uint32_t *files,uint32_t *chunks,uint64_t *length,uint64_t *size,uint64_t *rsize); void fs_add_files_to_chunks(); void fs_test_getdata(uint32_t *loopstart,uint32_t *loopend,uint32_t *files,uint32_t *ugfiles,uint32_t *mfiles,uint32_t *chunks,uint32_t *ugchunks,uint32_t *mchunks,char **msgbuff,uint32_t *msgbuffleng); uint32_t fs_test_log_inconsistency(fsedge *e,const char *iname,char *buff,uint32_t size); uint8_t fs_emptytrash(uint32_t ts,uint32_t freeinodes,uint32_t reservedinodes); uint8_t fs_emptyreserved(uint32_t ts,uint32_t freeinodes); uint64_t fs_getversion(); void fs_dumpedge(fsedge *e); void fs_dumpnode(fsnode *f); void fs_dumpnodes(); void fs_dumpedgelist(fsedge *e); void fs_dumpedges(fsnode *f); void fs_dumpfree(); void fs_dump(void); void fs_storeedge(fsedge *e,FILE *fd); int fs_loadedge(FILE *fd); void fs_storenode(fsnode *f,FILE *fd); void fs_storenodes(FILE *fd); void fs_storeedgelist(fsedge *e,FILE *fd); void fs_storeedges_rec(fsnode *f,FILE *fd); void fs_storeedges(FILE *fd); int fs_lostnode(fsnode *p); int fs_checknodes(); int fs_loadnodes(FILE *fd); int fs_loadedges(FILE *fd); void fs_storefree(FILE *fd); int fs_loadfree(FILE *fd); void fs_store(FILE *fd); int fs_loadnode_with_levelgoal(FILE *fd); int fs_loadnodes_with_levelgoal(FILE *fd); int fs_load_with_levelgoal(FILE *fd); void fs_storenode_with_levelgoal(fsnode *f,FILE *fd); void fs_storenodes_with_levelgoal(FILE *fd); void fs_store_with_levelgoal(FILE *fd); uint64_t fs_loadversion(FILE *fd); int fs_load(FILE *fd); void fs_new(void); int fs_emergency_storeall(const char *fname); int fs_emergency_saves(); void fs_dostoreall(void); void fs_term(void); void fs_storeall(const char *fname); void fs_term(const char *fname); int fs_loadall(void); void fs_strinit(void); void fs_cs_disconnected(void); int fs_init(void); int fs_init(const char *fname);
41ffb56c3e6daf46c18d6284c0b789b667842615f628aba9ec00b0204ffdc702
3,577
ialexyi
ATE
DRIVERs__PowerSupply__Lambda_Gen/GenPSie.c
GenPSie_selfTest
ViStatus _VI_FUNC GenPSie_selfTest (ViSession instrSession, ViPInt16 testResult, ViChar _VI_FAR testMessage[]) { ViStatus GenPSie_status = VI_SUCCESS; ViChar retStr [BUFFER_SIZE]; ViUInt32 retCnt; GenPSie_status = GenPSie_readQry (instrSession, "*TST?", retStr, &retCnt); if (GenPSie_status != VI_SUCCESS) return (GenPSie_status); if ( 0 == strcmp ("0", retStr)) { strcpy (testMessage, "Self-test passed"); *testResult = 0; } else { strcpy (testMessage, "Self-test failed"); *testResult = -1; } return (GenPSie_status); }
ViStatus _VI_FUNC GenPSie_sendCmd (ViSession instrSession, ViString cmdString); ViStatus _VI_FUNC GenPSie_close (ViSession instrSession); ViStatus _VI_FUNC GenPSie_setOvpMaxLevel (ViSession instrSession); ViStatus _VI_FUNC GenPSie_reset (ViSession instrSession); ViStatus _VI_FUNC GenPSie_saveSettings (ViSession instrSession); ViStatus _VI_FUNC GenPSie_recallSettings (ViSession instrSession); ViStatus GenPSie_convertErrNumb (ViInt32 systErr); ViBoolean GenPSie_invalidViBooleanRange (ViBoolean val); ViBoolean GenPSie_invalidViInt16Range (ViInt16 val, ViInt16 min, ViInt16 max); ViBoolean GenPSie_invalidViInt32Range (ViInt32 val, ViInt32 min, ViInt32 max); ViBoolean GenPSie_invalidViUInt8Range (ViUInt8 val, ViUInt8 min, ViUInt8 max); ViBoolean GenPSie_invalidViUInt16Range (ViUInt16 val, ViUInt16 min, ViUInt16 max); ViBoolean GenPSie_invalidViUInt32Range (ViUInt32 val, ViUInt32 min, ViUInt32 max); ViBoolean GenPSie_invalidViReal32Range (ViReal32 val, ViReal32 min, ViReal32 max); ViBoolean GenPSie_invalidViReal64Range (ViReal64 val, ViReal64 min, ViReal64 max); ViStatus _VI_FUNC GenPSie_STB (ViSession instrSession, ViUInt16* spollByte); void GenPSie_waitMS (ViUInt16 mSecWait); ViStatus GenPSie_defaultInstrSetup (ViSession instrSession);
1296c6f6351d80ea37a61baacfff2b7b96b9a3c444b771febf44c848e41aa362
721
Rajesh-Sec-Project
simon
hard.d/leds_board/soft/drivers/src_peripherals/stm32f10x_tim.c
TIM_SetIC1Prescaler
void TIM_SetIC1Prescaler(TIM_TypeDef* TIMx, uint16_t TIM_ICPSC) { assert_param(IS_TIM_LIST8_PERIPH(TIMx)); assert_param(IS_TIM_IC_PRESCALER(TIM_ICPSC)); TIMx->CCMR1 &= (uint16_t) ~((uint16_t)TIM_CCMR1_IC1PSC); TIMx->CCMR1 |= TIM_ICPSC; }
void TIM_DeInit(TIM_TypeDef* TIMx); void TIM_TimeBaseInit(TIM_TypeDef* TIMx, TIM_TimeBaseInitTypeDef* TIM_TimeBaseInitStruct); void TIM_OC1Init(TIM_TypeDef* TIMx, TIM_OCInitTypeDef* TIM_OCInitStruct); void TIM_OC2Init(TIM_TypeDef* TIMx, TIM_OCInitTypeDef* TIM_OCInitStruct); void TIM_OC3Init(TIM_TypeDef* TIMx, TIM_OCInitTypeDef* TIM_OCInitStruct); void TIM_OC4Init(TIM_TypeDef* TIMx, TIM_OCInitTypeDef* TIM_OCInitStruct); void TIM_ICInit(TIM_TypeDef* TIMx, TIM_ICInitTypeDef* TIM_ICInitStruct); void TIM_PWMIConfig(TIM_TypeDef* TIMx, TIM_ICInitTypeDef* TIM_ICInitStruct); void TIM_BDTRConfig(TIM_TypeDef* TIMx, TIM_BDTRInitTypeDef* TIM_BDTRInitStruct); void TIM_TimeBaseStructInit(TIM_TimeBaseInitTypeDef* TIM_TimeBaseInitStruct); void TIM_OCStructInit(TIM_OCInitTypeDef* TIM_OCInitStruct); void TIM_ICStructInit(TIM_ICInitTypeDef* TIM_ICInitStruct); void TIM_BDTRStructInit(TIM_BDTRInitTypeDef* TIM_BDTRInitStruct); void TIM_Cmd(TIM_TypeDef* TIMx, FunctionalState NewState); void TIM_CtrlPWMOutputs(TIM_TypeDef* TIMx, FunctionalState NewState); void TIM_ITConfig(TIM_TypeDef* TIMx, uint16_t TIM_IT, FunctionalState NewState); void TIM_GenerateEvent(TIM_TypeDef* TIMx, uint16_t TIM_EventSource); void TIM_DMAConfig(TIM_TypeDef* TIMx, uint16_t TIM_DMABase, uint16_t TIM_DMABurstLength); void TIM_DMACmd(TIM_TypeDef* TIMx, uint16_t TIM_DMASource, FunctionalState NewState); void TIM_InternalClockConfig(TIM_TypeDef* TIMx); void TIM_ITRxExternalClockConfig(TIM_TypeDef* TIMx, uint16_t TIM_InputTriggerSource); void TIM_TIxExternalClockConfig(TIM_TypeDef* TIMx, uint16_t TIM_TIxExternalCLKSource, uint16_t TIM_ICPolarity, uint16_t ICFilter); void TIM_ETRClockMode1Config(TIM_TypeDef* TIMx, uint16_t TIM_ExtTRGPrescaler, uint16_t TIM_ExtTRGPolarity, uint16_t ExtTRGFilter); void TIM_ETRClockMode2Config(TIM_TypeDef* TIMx, uint16_t TIM_ExtTRGPrescaler, uint16_t TIM_ExtTRGPolarity, uint16_t ExtTRGFilter); void TIM_ETRConfig(TIM_TypeDef* TIMx, uint16_t TIM_ExtTRGPrescaler, uint16_t TIM_ExtTRGPolarity, uint16_t ExtTRGFilter); void TIM_PrescalerConfig(TIM_TypeDef* TIMx, uint16_t Prescaler, uint16_t TIM_PSCReloadMode); void TIM_CounterModeConfig(TIM_TypeDef* TIMx, uint16_t TIM_CounterMode); void TIM_SelectInputTrigger(TIM_TypeDef* TIMx, uint16_t TIM_InputTriggerSource); void TIM_EncoderInterfaceConfig(TIM_TypeDef* TIMx, uint16_t TIM_EncoderMode, uint16_t TIM_IC1Polarity, uint16_t TIM_IC2Polarity); void TIM_ForcedOC1Config(TIM_TypeDef* TIMx, uint16_t TIM_ForcedAction); void TIM_ForcedOC2Config(TIM_TypeDef* TIMx, uint16_t TIM_ForcedAction); void TIM_ForcedOC3Config(TIM_TypeDef* TIMx, uint16_t TIM_ForcedAction); void TIM_ForcedOC4Config(TIM_TypeDef* TIMx, uint16_t TIM_ForcedAction); void TIM_ARRPreloadConfig(TIM_TypeDef* TIMx, FunctionalState NewState); void TIM_SelectCOM(TIM_TypeDef* TIMx, FunctionalState NewState); void TIM_SelectCCDMA(TIM_TypeDef* TIMx, FunctionalState NewState); void TIM_CCPreloadControl(TIM_TypeDef* TIMx, FunctionalState NewState); void TIM_OC1PreloadConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPreload); void TIM_OC2PreloadConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPreload); void TIM_OC3PreloadConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPreload); void TIM_OC4PreloadConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPreload); void TIM_OC1FastConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCFast); void TIM_OC2FastConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCFast); void TIM_OC3FastConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCFast); void TIM_OC4FastConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCFast); void TIM_ClearOC1Ref(TIM_TypeDef* TIMx, uint16_t TIM_OCClear); void TIM_ClearOC2Ref(TIM_TypeDef* TIMx, uint16_t TIM_OCClear); void TIM_ClearOC3Ref(TIM_TypeDef* TIMx, uint16_t TIM_OCClear); void TIM_ClearOC4Ref(TIM_TypeDef* TIMx, uint16_t TIM_OCClear); void TIM_OC1PolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPolarity); void TIM_OC1NPolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCNPolarity); void TIM_OC2PolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPolarity); void TIM_OC2NPolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCNPolarity); void TIM_OC3PolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPolarity); void TIM_OC3NPolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCNPolarity); void TIM_OC4PolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPolarity); void TIM_CCxCmd(TIM_TypeDef* TIMx, uint16_t TIM_Channel, uint16_t TIM_CCx); void TIM_CCxNCmd(TIM_TypeDef* TIMx, uint16_t TIM_Channel, uint16_t TIM_CCxN); void TIM_SelectOCxM(TIM_TypeDef* TIMx, uint16_t TIM_Channel, uint16_t TIM_OCMode); void TIM_UpdateDisableConfig(TIM_TypeDef* TIMx, FunctionalState NewState); void TIM_UpdateRequestConfig(TIM_TypeDef* TIMx, uint16_t TIM_UpdateSource); void TIM_SelectHallSensor(TIM_TypeDef* TIMx, FunctionalState NewState); void TIM_SelectOnePulseMode(TIM_TypeDef* TIMx, uint16_t TIM_OPMode); void TIM_SelectOutputTrigger(TIM_TypeDef* TIMx, uint16_t TIM_TRGOSource); void TIM_SelectSlaveMode(TIM_TypeDef* TIMx, uint16_t TIM_SlaveMode); void TIM_SelectMasterSlaveMode(TIM_TypeDef* TIMx, uint16_t TIM_MasterSlaveMode); void TIM_SetCounter(TIM_TypeDef* TIMx, uint16_t Counter); void TIM_SetAutoreload(TIM_TypeDef* TIMx, uint16_t Autoreload); void TIM_SetCompare1(TIM_TypeDef* TIMx, uint16_t Compare1); void TIM_SetCompare2(TIM_TypeDef* TIMx, uint16_t Compare2); void TIM_SetCompare3(TIM_TypeDef* TIMx, uint16_t Compare3); void TIM_SetCompare4(TIM_TypeDef* TIMx, uint16_t Compare4); void TIM_SetIC2Prescaler(TIM_TypeDef* TIMx, uint16_t TIM_ICPSC); void TIM_SetIC3Prescaler(TIM_TypeDef* TIMx, uint16_t TIM_ICPSC); void TIM_SetIC4Prescaler(TIM_TypeDef* TIMx, uint16_t TIM_ICPSC); void TIM_SetClockDivision(TIM_TypeDef* TIMx, uint16_t TIM_CKD); uint16_t TIM_GetCapture1(TIM_TypeDef* TIMx); uint16_t TIM_GetCapture2(TIM_TypeDef* TIMx); uint16_t TIM_GetCapture3(TIM_TypeDef* TIMx); uint16_t TIM_GetCapture4(TIM_TypeDef* TIMx); uint16_t TIM_GetCounter(TIM_TypeDef* TIMx); uint16_t TIM_GetPrescaler(TIM_TypeDef* TIMx); FlagStatus TIM_GetFlagStatus(TIM_TypeDef* TIMx, uint16_t TIM_FLAG); void TIM_ClearFlag(TIM_TypeDef* TIMx, uint16_t TIM_FLAG); ITStatus TIM_GetITStatus(TIM_TypeDef* TIMx, uint16_t TIM_IT); void TIM_ClearITPendingBit(TIM_TypeDef* TIMx, uint16_t TIM_IT); static void TI1_Config(TIM_TypeDef* TIMx, uint16_t TIM_ICPolarity, uint16_t TIM_ICSelection, uint16_t TIM_ICFilter); static void TI2_Config(TIM_TypeDef* TIMx, uint16_t TIM_ICPolarity, uint16_t TIM_ICSelection, uint16_t TIM_ICFilter); static void TI3_Config(TIM_TypeDef* TIMx, uint16_t TIM_ICPolarity, uint16_t TIM_ICSelection, uint16_t TIM_ICFilter); static void TI4_Config(TIM_TypeDef* TIMx, uint16_t TIM_ICPolarity, uint16_t TIM_ICSelection, uint16_t TIM_ICFilter);
0ed82c58a9a510bf4a3f5c49d1e90cb56779aba96e047a0f5b9ebb119e0a0d81
272
wayling
xboot-clone
src/arch/arm/mach-mid560/driver/s3c6410-mmc.c
ClearCommandCompleteStatus
static void ClearCommandCompleteStatus(void) { writew(S3C6410_HM_NORINTSTS1, 1 << 0); while (readw(S3C6410_HM_NORINTSTS1) & 0x1) { writew(S3C6410_HM_NORINTSTS1, 1 << 0); } }
static void set_cmd_register (u16_t cmd, u32_t data, u32_t flags); static int wait_for_cmd_done (void); static void ClearErrInterruptStatus(void); static void InterruptEnable(u16_t NormalIntEn, u16_t ErrorIntEn); static void set_hostctl_speed (u8_t mode); static void hsmmc_clock_onoff(bool_t on); static void set_clock (u32_t clksrc, u32_t div); static int issue_command (u16_t cmd, u32_t arg, u32_t data, u32_t flags); static int set_mmc_ocr (void); static int set_sd_ocr (void); static void display_card_info (void); static void mmc_init(void); static __init void s3c6410_mmc_init(void); static __exit void s3c6410_mmc_exit(void);
53583daeff6b093b0ed9bc3cefe4db9a8130578e115bcbef5a066332c4c9630e
179
Cabalist
Mycodo
2.0/mycodo/source/mycodo-1.7.c
CheckTemp
int CheckTemp (void) { if ( temp < minTemp ) { tempState = 1; printf("< minTemp. Heat On."); } else if ( temp >= minTemp && temp < maxTemp) { tempState = 2; printf(">= minTemp. Heat off until < minTemp."); } else if ( temp >= highTemp ) { tempState = 3; printf("> highTemp. Heat Off, All fans On."); } else { if ( tempState == 2 ) printf("Heat off until < minTemp."); else printf("Heat on until > minTemp."); return; } writeCfg(); return 0; }
int main( int argc, char *argv[] ); int readCfg (void); int writeCfg (void); int CheckHum (void); int ChangeRelays (double tdiff, double hdiff);
8b3001cdcb5f48ed486f17d70b7ad2bb2e546a98b833f352f9aedcdde10241bd
477
dduval
kernel-rhel4
drivers/xen/xenbus/xenbus_probe.c
exists_disconnected_device
static int exists_disconnected_device(struct device_driver *drv) { if (xenbus_frontend.error) return xenbus_frontend.error; return bus_for_each_dev(&xenbus_frontend.bus, NULL, drv, is_disconnected_device); }
static int xenbus_match(struct device *_dev, struct device_driver *_drv); static int frontend_bus_id(char bus_id[BUS_ID_SIZE], const char *nodename); static void free_otherend_details(struct xenbus_device *dev); static void free_otherend_watch(struct xenbus_device *dev); static int read_backend_details(struct xenbus_device *xendev); static int read_frontend_details(struct xenbus_device *xendev); static int backend_bus_id(char bus_id[BUS_ID_SIZE], const char *nodename); static int talk_to_otherend(struct xenbus_device *dev); static int watch_otherend(struct xenbus_device *dev); static int xenbus_dev_probe(struct device *_dev); static int xenbus_dev_remove(struct device *_dev); static void xenbus_dev_shutdown(struct device *_dev); int xenbus_register_frontend(struct xenbus_driver *drv); int xenbus_register_backend(struct xenbus_driver *drv); void xenbus_unregister_driver(struct xenbus_driver *drv); static int cmp_dev(struct device *dev, void *data); static int cleanup_dev(struct device *dev, void *data); static void xenbus_cleanup_devices(const char *path, struct bus_type *bus); static void xenbus_dev_release(struct device *dev); char *kasprintf(gfp_t gfp, const char *fmt, ...); static ssize_t xendev_show_nodename(struct device *dev, char *buf); static ssize_t xendev_show_devtype(struct device *dev, char *buf); static int xenbus_probe_frontend(const char *type, const char *name); static int xenbus_probe_backend(const char *type, const char *domid); static int xenbus_probe_device_type(struct xen_bus_type *bus, const char *type); static int xenbus_probe_devices(struct xen_bus_type *bus); static unsigned int char_count(const char *str, char c); static int strsep_len(const char *str, char c, unsigned int len); static void dev_changed(const char *node, struct xen_bus_type *bus); static int suspend_dev(struct device *dev, void *data); static int suspend_cancel_dev(struct device *dev, void *data); static int resume_dev(struct device *dev, void *data); void xenbus_suspend(void); void xenbus_resume(void); void xenbus_suspend_cancel(void); int register_xenstore_notifier(struct notifier_block *nb); void unregister_xenstore_notifier(struct notifier_block *nb); static int all_devices_ready_(struct device *dev, void *data); static int all_devices_ready(void); void xenbus_probe(void *unused); static int xsd_kva_mmap(struct file *file, struct vm_area_struct *vma); static int __init xenbus_probe_init(void); int xenbus_init(void); static int is_disconnected_device(struct device *dev, void *data); static int print_device_status(struct device *dev, void *data); static void wait_for_devices(struct xenbus_driver *xendrv); static int __init boot_wait_for_devices(void);
a9d477ab392f8d1bd3586ea11e83c3b689c7706f7079d7533a48e69f9d8a5973
237
jcmcclurg
serverpower
unused/transcoders/libav-11.4/libavcodec/libgsmenc.c
libgsm_encode_init
static av_cold int libgsm_encode_init(AVCodecContext *avctx) { if (avctx->channels > 1) { av_log(avctx, AV_LOG_ERROR, "Mono required for GSM, got %d channels\n", avctx->channels); return -1; } if (avctx->sample_rate != 8000) { av_log(avctx, AV_LOG_ERROR, "Sample rate 8000Hz required for GSM, got %dHz\n", avctx->sample_rate); if (avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL) return -1; } if (avctx->bit_rate != 13000 && avctx->bit_rate != 13200 && avctx->bit_rate != 0 ) { av_log(avctx, AV_LOG_ERROR, "Bitrate 13000bps required for GSM, got %dbps\n", avctx->bit_rate); if (avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL) return -1; } avctx->priv_data = gsm_create(); switch(avctx->codec_id) { case AV_CODEC_ID_GSM: avctx->frame_size = GSM_FRAME_SIZE; avctx->block_align = GSM_BLOCK_SIZE; break; case AV_CODEC_ID_GSM_MS: { int one = 1; gsm_option(avctx->priv_data, GSM_OPT_WAV49, &one); avctx->frame_size = 2*GSM_FRAME_SIZE; avctx->block_align = GSM_MS_BLOCK_SIZE; } } return 0; }
static av_cold int libgsm_encode_close(AVCodecContext *avctx);
4280c5bd0493b2b452c9609a1f589132f4488b48773014755ac124966d6b0fc3
1,257
Denshikobo-Life
bcmlib_for_java
common/bi_common.c
dump_buff
void dump_buff(void) { int i; printf("pid=%d ",pid); printf("w_buff=%08x wp=%d rp=%d \n",w_buff,w_buff->wp,w_buff->rp); printf("r_buff=%08x wp=%d rp=%d \n",r_buff,r_buff->wp,r_buff->rp); for( i=0;i<wp;i++) { printf("%02x ",buff[i]); } printf(" \n"); }
int calc_data_size( struct ring_buff *rb); int calc_rest_size( struct ring_buff *rb); int put_ring_buff(struct ring_buff *rb, char *str, int len ); int get_ring_buff(struct ring_buff *rb, char *buff, int max_len); void init_ring_buff(struct ring_buff *rb, int init_type); void set_ope_code( unsigned char ope_code); void set_byte_code( unsigned char code); void set_short_code( short int code ); void set_int_code( int code); void set_long_code( long code); void get_ope_code( void ); void get_byte_code( void ); void get_short_code( void ); void get_int_code( void ); void get_long_code( void ); void copy_str( char *dest, char* src, int len); int context_switch( int max_count);
4325995241b02a6400c685184af2d677efbf547f8ce2868fd7d60ca92e5b2c82
291
scs
uclinux
user/blkfin-apps/vlc/vlc-0.8.6b/src/playlist/playlist.c
playlist_PreparseEnqueueItem
int playlist_PreparseEnqueueItem( playlist_t *p_playlist, playlist_item_t *p_item ) { vlc_mutex_lock( &p_playlist->object_lock ); vlc_mutex_lock( &p_playlist->p_preparse->object_lock ); playlist_PreparseEnqueueItemSub( p_playlist, p_item ); vlc_mutex_unlock( &p_playlist->p_preparse->object_lock ); vlc_mutex_unlock( &p_playlist->object_lock ); return VLC_SUCCESS; }
playlist_item_t *playlist_RecursiveFindLast(playlist_t *p_playlist, playlist_item_t *p_node ); playlist_t * __playlist_Create ( vlc_object_t *p_parent ); int playlist_Destroy( playlist_t * p_playlist ); int playlist_LockControl( playlist_t * p_playlist, int i_query, ... ); int playlist_Control( playlist_t * p_playlist, int i_query, ... ); int playlist_vaControl( playlist_t * p_playlist, int i_query, va_list args ); int playlist_PreparseEnqueue( playlist_t *p_playlist, input_item_t *p_item ); void playlist_PreparseEnqueueItemSub( playlist_t *p_playlist, playlist_item_t *p_item ); static mtime_t ObjectGarbageCollector( playlist_t *p_playlist, int i_type, mtime_t destroy_date ); static void RunThread ( playlist_t *p_playlist ); static void RunPreparse ( playlist_preparse_t *p_obj ); static playlist_item_t * NextItem( playlist_t *p_playlist ); static int PlayItem( playlist_t *p_playlist, playlist_item_t *p_item );
3ceb705c71b926b097fbe56e6c3d9f13b1ea60ccd4029afccde7c217c990b94c
425
sisuani
iaxclient
lib/libiax2/src/iax.c
iax_enable_jitterbuffer
void iax_enable_jitterbuffer(void) { iax_use_jitterbuffer = 1; }
void iax_enable_debug(void); void iax_disable_debug(void); void iax_disable_jitterbuffer(void); void iax_set_private(struct iax_session *s, void *ptr); void *iax_get_private(struct iax_session *s); void iax_set_sendto(struct iax_session *s, iax_sendto_t ptr); static int __debug(const char *file, int lineno, const char *fmt, ...); static int __debug(const char *file, int lineno, const char *func, const char *fmt, ...); void iax_seed_random(); int iax_random(); unsigned int iax_session_get_capability(struct iax_session *s); static int inaddrcmp(struct sockaddr_in *sin1, struct sockaddr_in *sin2); static int iax_sched_add(struct iax_event *event, struct iax_frame *frame, sched_func func, void *arg, int ms); static int iax_sched_del(struct iax_event *event, struct iax_frame *frame, sched_func func, void *arg, int all); int iax_time_to_next_event(void); struct iax_session *iax_session_new(void); static int iax_session_valid(struct iax_session *session); int iax_get_netstats(struct iax_session *session, int *rtt, struct iax_netstat *local, struct iax_netstat *remote); static void add_ms(struct timeval *tv, int ms); static int calc_timestamp(struct iax_session *session, unsigned int ts, struct ast_frame *f); static unsigned char get_n_bits_at(unsigned char *data, int n, int bit); static int speex_get_wb_sz_at(unsigned char *data, int len, int bit); static int speex_get_samples(unsigned char *data, int len); static inline int get_interp_len(int format); static int get_sample_cnt(struct iax_event *e); static int iax_xmit_frame(struct iax_frame *f); static int iax_reliable_xmit(struct iax_frame *f); void iax_set_networking(iax_sendto_t st, iax_recvfrom_t rf); void iax_set_jb_target_extra( long value ); int iax_init(int preferredportno);
e1572771bbda6c49fdb68524da23c6bcde97e66275a14b7918cbeb6b9227691d
66
danielgpalmer
linux-picosam9g45
sound/usb/pcm.c
snd_usb_pcm_pointer
static snd_pcm_uframes_t snd_usb_pcm_pointer(struct snd_pcm_substream *substream) { struct snd_usb_substream *subs; unsigned int hwptr_done; subs = (struct snd_usb_substream *)substream->runtime->private_data; spin_lock(&subs->lock); hwptr_done = subs->hwptr_done; substream->runtime->delay = snd_usb_pcm_delay(subs, substream->runtime->rate); spin_unlock(&subs->lock); return hwptr_done / (substream->runtime->frame_bits >> 3); }
static int start_endpoints(struct snd_usb_substream *subs); static int activate_endpoints(struct snd_usb_substream *subs); static int deactivate_endpoints(struct snd_usb_substream *subs); static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt); static int snd_usb_hw_free(struct snd_pcm_substream *substream); static int snd_usb_pcm_prepare(struct snd_pcm_substream *substream); static int setup_hw_info(struct snd_pcm_runtime *runtime, struct snd_usb_substream *subs); static int snd_usb_pcm_open(struct snd_pcm_substream *substream, int direction); static int snd_usb_pcm_close(struct snd_pcm_substream *substream, int direction); static int snd_usb_playback_open(struct snd_pcm_substream *substream); static int snd_usb_playback_close(struct snd_pcm_substream *substream); static int snd_usb_capture_open(struct snd_pcm_substream *substream); static int snd_usb_capture_close(struct snd_pcm_substream *substream); int snd_usb_substream_capture_trigger(struct snd_pcm_substream *substream, int cmd); void snd_usb_set_pcm_ops(struct snd_pcm *pcm, int stream);
d0d80838d7dd0be7f246633816aa1af2fc9776908f2e95cd30ccb651e2503b3c
446
bogus
mydlp-host-win32
libclamav/scanners.c
cli_scanmschm
static int cli_scanmschm(int desc, cli_ctx *ctx) { int ret = CL_CLEAN, rc; chm_metadata_t metadata; char *dir; cli_dbgmsg("in cli_scanmschm()\n"); if(!(dir = cli_gentemp(ctx->engine->tmpdir))) return CL_EMEM; if(mkdir(dir, 0700)) { cli_dbgmsg("CHM: Can't create temporary directory %s\n", dir); free(dir); return CL_ETMPDIR; } ret = cli_chm_open(desc, dir, &metadata, ctx); if (ret != CL_SUCCESS) { if(!ctx->engine->keeptmp) cli_rmdirs(dir); free(dir); cli_dbgmsg("CHM: Error: %s\n", cl_strerror(ret)); return ret; } do { ret = cli_chm_prepare_file(&metadata); if (ret != CL_SUCCESS) { break; } ret = cli_chm_extract_file(dir, &metadata, ctx); if (ret == CL_SUCCESS) { lseek(metadata.ofd, 0, SEEK_SET); rc = cli_magic_scandesc(metadata.ofd, ctx); close(metadata.ofd); if (rc == CL_VIRUS) { cli_dbgmsg("CHM: infected with %s\n",*ctx->virname); ret = CL_VIRUS; break; } } } while(ret == CL_SUCCESS); cli_chm_close(&metadata); if(!ctx->engine->keeptmp) cli_rmdirs(dir); free(dir); cli_dbgmsg("CHM: Exit code: %d\n", ret); if (ret == CL_BREAK) ret = CL_CLEAN; return ret; }
static int cli_unrar_scanmetadata(int desc, unrar_metadata_t *metadata, cli_ctx *ctx, unsigned int files, uint32_t* sfx_check); static int cli_scanrar(int desc, cli_ctx *ctx, off_t sfx_offset, uint32_t *sfx_check); static int cli_scanarj(int desc, cli_ctx *ctx, off_t sfx_offset, uint32_t *sfx_check); static int cli_scangzip_with_zib_from_the_80s(cli_ctx *ctx, unsigned char *buff); static int cli_scangzip(cli_ctx *ctx); static int cli_scanbzip(int desc, cli_ctx *ctx); static int cli_scanbzip(int desc, cli_ctx *ctx); static int cli_scanszdd(int desc, cli_ctx *ctx); static int cli_scanmscab(int desc, cli_ctx *ctx, off_t sfx_offset); static int cli_scanhtml(cli_ctx *ctx); static int cli_scanscript(cli_ctx *ctx); static int cli_scanhtml_utf16(cli_ctx *ctx); static int cli_scanole2(cli_ctx *ctx); static int cli_scanole2_structured(cli_ctx *ctx); static int cli_scanpdf_structured(cli_ctx *ctx); static int cli_scanps_structured(cli_ctx *ctx); static int cli_scantar(int desc, cli_ctx *ctx, unsigned int posix); static int cli_scanscrenc(int desc, cli_ctx *ctx); static int cli_scanriff(int desc, cli_ctx *ctx); static int cli_scanjpeg(int desc, cli_ctx *ctx); static int cli_scancryptff(int desc, cli_ctx *ctx); static int cli_scanpdf(cli_ctx *ctx, off_t offset); static int cli_scantnef(int desc, cli_ctx *ctx); static int cli_scanuuencoded(cli_ctx *ctx); static int cli_scanmail(int desc, cli_ctx *ctx); static int cli_scan_structured(int desc, cli_ctx *ctx); static int cli_scanembpe(int desc, cli_ctx *ctx); static int cli_scanraw(cli_ctx *ctx, cli_file_t type, uint8_t typercg, cli_file_t *dettype, unsigned char *refhash); static void emax_reached(cli_ctx *ctx); int cli_magic_scandesc(int desc, cli_ctx *ctx); int cl_scandesc(int desc, const char **virname, unsigned long int *scanned, const struct cl_engine *engine, unsigned int scanoptions); int cli_found_possibly_unwanted(cli_ctx* ctx); static int cli_scanfile(const char *filename, cli_ctx *ctx); int cl_scanfile(const char *filename, const char **virname, unsigned long int *scanned, const struct cl_engine *engine, unsigned int scanoptions);
8991e47ed1d6d67c38b212f6570940197b51f710ab0dfede1453024dc06cf404
1,209
execunix
vinos
gnu/dist/diffutils/src/context.c
void print_context_header
void print_context_header (struct file_data inf[], bool unidiff) { if (unidiff) { print_context_label ("---", &inf[0], file_label[0]); print_context_label ("+++", &inf[1], file_label[1]); } else { print_context_label ("***", &inf[0], file_label[0]); print_context_label ("---", &inf[1], file_label[1]); } }
55e2ab3ec5a26df9c8e325374fc390d63b81a7a129c349c0a29f9db5d5d5e4db
351
Alex-V2
One_M8_4.4.3_kernel
drivers/media/platform/msm/camera_v2/sensor/actuator/LC898111/OisCmd.c
; if
UnDwdVal StTneVal, unsigned char UcTneAxs ) { long SlSetBia ; unsigned short UsSetBia ; unsigned char UcChkFst ; static unsigned short UsTneVax ; UcChkFst = 1 ; if ( UsStpSiz == 1) { UsTneVax = 2 ; if ( ( StTneVal.StDwdVal.UsHigVal + StTneVal.StDwdVal.UsLowVal ) / 2 < BIAS_ADJ_BORDER ) { UcChkFst = 0 ; } if( ( UcTneAxs & 0xF0 ) && UcChkFst ) { ; }else{ if ( !UcTneAxs ) { RamWriteA( DAHLXB, 0x8001 ) ; RamWriteA( DAHLXO, 0x0000 ) ; UsStpSiz = BIAS_LIMIT / UsTneVax ; } else { RamWriteA( DAHLYB, 0x8001 ) ; RamWriteA( DAHLYO, 0x0000 ) ; UsStpSiz = BIAS_LIMIT / UsTneVax ; } } } if ( !( UcTneAxs & 0x0F ) ) { RamReadA( DAHLXB, &UsSetBia ) ; SlSetBia = ( long )UsSetBia ; } else { RamReadA( DAHLYB, &UsSetBia ) ; SlSetBia = ( long )UsSetBia ; } if( SlSetBia > 0x00008000 ) { SlSetBia |= 0xFFFF0000 ; } if( UcChkFst ) { if( UcTneAxs & 0xF0 ) { if ( ( StTneVal.StDwdVal.UsHigVal + StTneVal.StDwdVal.UsLowVal ) / 2 > BIAS_ADJ_BORDER ) { SlSetBia += 0x0100 ; } else { SlSetBia -= 0x0100 ; } UsStpSiz = 0x0200 ; }else{ if ( ( StTneVal.StDwdVal.UsHigVal + StTneVal.StDwdVal.UsLowVal ) / 2 > BIAS_ADJ_BORDER ) { SlSetBia += UsStpSiz ; } else { SlSetBia -= UsStpSiz ; } UsTneVax = UsTneVax * 2 ; UsStpSiz = BIAS_LIMIT / UsTneVax ; } } if( SlSetBia > ( long )0x00007FFF ) { SlSetBia = 0x00007FFF ; } else if( SlSetBia < ( long )0xFFFF8001 ) { SlSetBia = 0xFFFF8001 ; } if ( !( UcTneAxs & 0x0F ) ) { RamWriteA( DAHLXB, SlSetBia ) ; } else { RamWriteA( DAHLYB, SlSetBia ) ; } StTneVal.UlDwdVal = TnePtp( UcTneAxs & 0x0F , PTP_AFTER ) ; return( StTneVal.UlDwdVal ) ; }
unsigned short TneRun( void ); unsigned long TnePtp ( unsigned char UcDirSel, unsigned char UcBfrAft ); unsigned char UcTneAxs, UnDwdVal StTneVal ); UnDwdVal StTneVal, unsigned char UcTneAxs ); char UcMesMod ); char UcDirSel, unsigned char UcSwcCon ); unsigned char UcDirSel ); char UcDirSel ); char UcDirSel ); char UcDirSel, unsigned char UcSonOff ); unsigned char UcDirSel ); BsyWit( DLYCLR2, 0xC0 ); unsigned char UcXg1Xg2 ); void ); riteA( GSHTON, 0x00 ); DIR, ON ); STR ); H1COEF_CHANGER SetH1cMod( S2MODE ); ); p,X-amp,DAC,ADC Standby */ RegWriteA( PWMA, 0x00 ); oomStepDat > (ZOOMTBL - 1); iteA( HXINOD , UsOptXval ); Ý’肵‚Ä‚­‚¾‚³‚¢@ // - RAM:1290h`12A8h (ƒTƒCƒ“”gƒe[ƒuƒ‹); 0E3 [ SINXADD(7:0); //============================================================================== // Function : StopMeasFil(); /============================================================================== // Function : LoopGainAdj(); ( GYRO_GAIN_X, 4, ( unsigned char * ); 0x0083 Linear•â³OFF RegWriteA( LYEQFC2 , 0x00 ); Filter1 Equalizer ON RegWriteA( MSF2EN, 0x01 ); gyl2b_2, MAXLMT );
7c8b50bb0ec6df1d1e22b183b68eb8d1a36b6eb27d4efa34bd02deb6bcee31e3
1,809
ryo-on
vmkdrivers-gpl
vmkdrivers/src_9/drivers/net/nx_nic/unm_nic_main.c
vlan_accel_setup
static void vlan_accel_setup(struct unm_adapter_s *adapter, struct net_device *netdev) { if (adapter->ahw.fw_capabilities_1 & NX_FW_CAPABILITY_FVLANTX) { netdev->features |= NETIF_F_HW_VLAN_RX; netdev->vlan_rx_register = nx_vlan_rx_register; netdev->vlan_rx_kill_vid = nx_rx_kill_vid; netdev->features |= NETIF_F_HW_VLAN_TX; NX_NIC_TRC_FN(adapter, vlan_accel_setup, NX_FW_CAPABILITY_FVLANTX); } }
U32 nx_os_free_mem(nx_dev_handle_t handle, void *addr, U32 len, U32 flags); void nx_os_nic_reg_read_w0(nx_dev_handle_t handle, U32 index, U32 * value); void nx_os_nic_reg_write_w0(nx_dev_handle_t handle, U32 index, U32 value); void nx_os_nic_reg_read_w1(nx_dev_handle_t handle, U64 off, U32 * value); void nx_os_nic_reg_write_w1(nx_dev_handle_t handle, U64 off, U32 val); void nx_init_napi (struct unm_adapter_s *adapter); void nx_napi_enable(struct unm_adapter_s *adapter); void nx_napi_disable(struct unm_adapter_s *adapter); static int nx_alloc_adapter_sds_rings(struct unm_adapter_s *adapter); static void nx_verify_module_params(void); static void unm_check_options(unm_adapter *adapter); static int get_flash_mac_addr(struct unm_adapter_s *adapter, uint64_t mac[]); static int initialize_dummy_dma(unm_adapter *adapter); static void destroy_dummy_dma(unm_adapter *adapter); static void nx_reset_msix_bit(struct pci_dev *pdev); static int nx_nic_setup_minidump(struct unm_adapter_s *adapter); static void nx_nic_cleanup_minidump(struct unm_adapter_s *adapter); static void nx_nic_logs_free (struct unm_adapter_s *adapter); static void cleanup_adapter(struct unm_adapter_s *adapter); static int nx_set_dma_mask(struct unm_adapter_s *adapter, uint8_t revision_id); static void nx_set_num_rx_queues(unm_adapter *adapter); static void init_msix_entries(struct unm_adapter_s *adapter); static inline int unm_pci_region_offset(struct pci_dev *pdev, int region); static inline int unm_pci_region_len(struct pci_dev *pdev, int region); static void nx_hwbug_8_workaround(struct pci_dev *pdev); static int nx_enable_msi_x(struct unm_adapter_s *adapter); static int nx_enable_msi(struct unm_adapter_s *adapter); static int nx_read_flashed_versions(struct unm_adapter_s *adapter); static int nx_start_firmware(struct unm_adapter_s *adapter); static int __devinit get_adapter_attr(struct unm_adapter_s *adapter); static void nx_rx_kill_vid(struct net_device *netdev, unsigned short vid); static int initialize_adapter_hw(struct unm_adapter_s *adapter); static int init_firmware(struct unm_adapter_s *adapter); static void unm_nic_free_ring_context(struct unm_adapter_s *adapter); static void unm_nic_free_ring_context_in_fw(struct unm_adapter_s *adapter, int ctx_destroy); void unm_nic_free_hw_resources(struct unm_adapter_s *adapter); static void inline unm_nic_clear_stats(struct unm_adapter_s *adapter); static int unm_nic_attach(struct unm_adapter_s *adapter); static void nx_nic_p3_free_mac_list(struct unm_adapter_s *adapter); static void unm_nic_detach(struct unm_adapter_s *adapter, int ctx_destroy); static void __devexit unm_nic_remove(struct pci_dev *pdev); static int nx_config_rss(struct unm_adapter_s *adapter, int enable); int nx_nic_multictx_get_filter_count(struct net_device *netdev, int queue_type); struct napi_struct * nx_nic_multictx_get_napi(struct net_device *netdev , int queue_id); int nx_nic_multictx_get_ctx_count(struct net_device *netdev, int queue_type); int nx_nic_multictx_get_queue_vector(struct net_device *netdev, int qid); int nx_nic_multictx_get_default_rx_queue(struct net_device *netdev); int nx_nic_multictx_alloc_tx_ctx(struct net_device *netdev); int nx_nic_multictx_alloc_rx_ctx(struct net_device *netdev); int nx_nic_create_rx_ctx(struct net_device *netdev); int nx_nic_multictx_free_tx_ctx(struct net_device *netdev, int ctx_id); int nx_nic_multictx_free_rx_ctx(struct net_device *netdev, int ctx_id); int nx_nic_multictx_set_rx_rule(struct net_device *netdev, int ctx_id, char* mac_addr); int nx_nic_multictx_remove_rx_rule(struct net_device *netdev, int ctx_id, int rule_id); int nx_pqm_queuelen (struct unm_adapter_s *adapter, int qnum); int nx_testmux_lock(struct unm_adapter_s *adapter); int nx_testmux_unlock(struct unm_adapter_s *adapter); static void nx_clear_all_tm(struct unm_adapter_s *adapter); static void nx_sre_status (struct unm_adapter_s *adapter); static void nx_epg_status (struct unm_adapter_s *adapter); static void nx_peg_status(struct unm_adapter_s *adapter); static void nx_phanstat(struct unm_adapter_s *adapter); static void nx_pegconsole(struct unm_adapter_s *adapter); static void nx_sre_statistics (struct unm_adapter_s *adapter); static void nx_epg_statistics (struct unm_adapter_s *adapter); static void nx_nic_regs (struct unm_adapter_s *adapter); static void nx_mac_statistics (struct unm_adapter_s *adapter); int nx_nic_minidump(struct unm_adapter_s *adapter); static void nx_nic_collect_fw_logs (struct unm_adapter_s *adapter); static int unm_nic_open(struct net_device *netdev); static int receive_peg_ready(struct unm_adapter_s *adapter); static int unm_nic_hw_resources(struct unm_adapter_s *adapter); static int unm_nic_new_rx_context_destroy(struct unm_adapter_s *adapter, int ctx_destroy); static int unm_nic_new_tx_context_prepare(struct unm_adapter_s *adapter); static int unm_nic_new_tx_context_destroy(struct unm_adapter_s *adapter, int ctx_destroy); void nx_free_tx_resources(struct unm_adapter_s *adapter); static void unm_nic_down(struct net_device *netdev); static int unm_nic_close(struct net_device *netdev); static int unm_nic_set_mac(struct net_device *netdev, void *p); static void nx_nic_p3_set_multi(struct net_device *netdev); static inline int is_packet_tagged(struct sk_buff *skb); int unm_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev); static void unm_watchdog_fw_reset(unsigned long v); static void unm_watchdog(unsigned long v); static int unm_nic_check_temp(struct unm_adapter_s *adapter); int nx_p3_set_vport_miss_mode(struct unm_adapter_s *adapter, int mode); static void unm_nic_handle_phy_intr(struct unm_adapter_s *adapter); int nx_reset_netq_rx_queues( struct net_device *netdev); int netxen_nic_attach_all_ports(struct unm_adapter_s *adapter); int check_fw_reset_failure(struct unm_adapter_s *adapter); int netxen_nic_restart_fw(struct unm_adapter_s *adapter); int netxen_nic_reset_tx_timeout(struct unm_adapter_s *adapter); int netxen_nic_detach_all_ports(struct unm_adapter_s *adapter, int fw_health); void nx_nic_halt_firmware(struct unm_adapter_s *adapter); static void unm_watchdog_task_fw_reset(TASK_PARAM adapid); static void unm_watchdog_task(TASK_PARAM adapid); static void unm_tx_timeout(struct net_device *netdev); static void unm_tx_timeout_task(TASK_PARAM adapid); static struct net_device_stats *unm_nic_get_stats(struct net_device *netdev); static int nx_nic_fw40_change_mtu(struct net_device *netdev, int new_mtu); irqreturn_t nx_nic_legacy_intr(int irq, void *data); irqreturn_t nx_nic_msi_intr(int irq, void *data); irqreturn_t nx_nic_msix_intr(int irq, void *data); static int nx_nic_poll_sts(struct napi_struct *napi, int work_to_do); static void unm_nic_poll_controller(struct net_device *netdev); static inline void lro2_adjust_skb(struct sk_buff *skb, statusDesc_t *desc); int nx_nic_is_netxen_device(struct net_device *netdev); int nx_nic_get_device_port(struct net_device *netdev); static int unm_process_cmd_ring(unsigned long data); static inline int nx_pci_choose_state(struct pci_dev *pdev, PM_MESSAGE_T state); static int unm_nic_suspend(struct pci_dev *pdev, PM_MESSAGE_T state); static int unm_nic_resume(struct pci_dev *pdev); static int __init unm_init_module(void); static void __exit unm_exit_module(void); int nx_nic_get_linkevent_cap(struct unm_adapter_s *adapter);
4b8a64253163608e08eb3e5406dfb0da0c65850fa762913e6e98a9ae22598411
413
DmitryADP
diff_qc750
vendor/nvidia/tegra/multimedia-partner/nvmm/nvmm/blocks/super_parser/parser_core/ogg/nvmm_oggframing.c
NvOggSyncPageseek
NvS32 NvOggSyncPageseek(ogg_sync_state *oy,ogg_page *og){ NvOggByteBuffer page; NvS32 bytes,ret=0; NvOggPageRelease(og); bytes=oy->fifo_fill; NvOggbyteInit(&page,oy->fifo_tail); if(oy->headerbytes==0){ if(bytes<27)goto sync_out; if(NvOggbyteRead1(&page,0)!=(NvS32)'O' || NvOggbyteRead1(&page,1)!=(NvS32)'g' || NvOggbyteRead1(&page,2)!=(NvS32)'g' || NvOggbyteRead1(&page,3)!=(NvS32)'S' ) goto sync_fail; oy->headerbytes=NvOggbyteRead1(&page,26)+27; } if(bytes<oy->headerbytes)goto sync_out; if(oy->bodybytes==0){ NvS32 i; for(i=0;i<oy->headerbytes-27;i++) oy->bodybytes+=NvOggbyteRead1(&page,27+i); } if(oy->bodybytes+oy->headerbytes>bytes)goto sync_out; { ogg_uint32_t chksum=NvOggbyteRead4(&page,22); NvOggbyteSet4(&page,0,22); if(chksum!=NvChecksum(oy->fifo_tail,oy->bodybytes+oy->headerbytes)){ NvOggbyteSet4(&page,chksum,22); goto sync_fail; } NvOggbyteSet4(&page,chksum,22); } if(og){ og->header=NvOggBufferSplit(&oy->fifo_tail,&oy->fifo_head,oy->headerbytes); og->header_len=oy->headerbytes; og->body=NvOggBufferSplit(&oy->fifo_tail,&oy->fifo_head,oy->bodybytes); og->body_len=oy->bodybytes; }else{ oy->fifo_tail= NvOggBufferPretruncate(oy->fifo_tail,oy->headerbytes+oy->bodybytes); if(!oy->fifo_tail)oy->fifo_head=0; } ret=oy->headerbytes+oy->bodybytes; oy->unsynced=0; oy->headerbytes=0; oy->bodybytes=0; oy->fifo_fill-=ret; return ret; sync_fail: oy->headerbytes=0; oy->bodybytes=0; oy->fifo_tail=NvOggBufferPretruncate(oy->fifo_tail,1); ret--; while(oy->fifo_tail){ NvU8 *now=oy->fifo_tail->buffer->data+oy->fifo_tail->begin; NvU8 *next=memchr(now, 'O', oy->fifo_tail->length); if(next){ NvS32 bytes=next-now; oy->fifo_tail=NvOggBufferPretruncate(oy->fifo_tail,bytes); ret-=bytes; break; }else{ NvS32 bytes=oy->fifo_tail->length; ret-=bytes; oy->fifo_tail=NvOggBufferPretruncate(oy->fifo_tail,bytes); } } if(!oy->fifo_tail)oy->fifo_head=0; oy->fifo_fill+=ret; sync_out: return ret; }
static ogg_buffer_state *NvOggBufferCreate(void); void NvOggBufferDestroy(ogg_buffer_state *bs); ogg_buffer *NvFetchBuffer(ogg_buffer_state *bs,NvS32 bytes); ogg_reference *NvFetchRef(ogg_buffer_state *bs); ogg_reference *NvOggBufferAlloc(ogg_buffer_state *bs,NvS32 bytes); void NvOggBufferRealloc(ogg_reference *or,NvS32 bytes); void NvOggBufferMarkOne(ogg_reference *or); void NvOggBufferMark(ogg_reference *or); ogg_reference *NvOggBufferSub(ogg_reference *or,NvS32 begin,NvS32 length); ogg_reference *NvOggBufferDup(ogg_reference *or); ogg_reference *NvOggBufferSplit(ogg_reference **tail, ogg_reference **head,NvS32 pos); void NvOggBufferReleaseOne(ogg_reference *or); void NvOggBufferRelease(ogg_reference *or); ogg_reference *NvOggBufferPretruncate(ogg_reference *or,NvS32 pos); static ogg_reference *NvOggBufferWalk(ogg_reference *or); ogg_reference *NvOggBufferCat(ogg_reference *tail, ogg_reference *head); void NvPositionB(NvOggByteBuffer *b,NvS32 pos); void NvPositionF(NvOggByteBuffer *b,NvS32 pos); NvS32 NvOggbyteInit(NvOggByteBuffer *b,ogg_reference *or); void NvOggbyteSet4(NvOggByteBuffer *b,ogg_uint32_t val,NvS32 pos); NvU8 NvOggbyteRead1(NvOggByteBuffer *b,NvS32 pos); ogg_uint32_t NvOggbyteRead4(NvOggByteBuffer *b,NvS32 pos); ogg_int64_t NvOggbyteRead8(NvOggByteBuffer *b,NvS32 pos); NvS32 NvOggPageVersion(ogg_page *og); NvS32 NvOggPageBos(ogg_page *og); ogg_uint32_t NvOggPagePageno(ogg_page *og); ogg_uint32_t NvChecksum(ogg_reference *or, NvS32 bytes); void NvNextLace(NvOggByteBuffer *ob,ogg_stream_state *os); void NVSpanQueuedPage(ogg_stream_state *os); NvS32 NvPacketout(ogg_stream_state *os,NvOggPacket *op,NvS32 adv); NvS32 NvOggStreamPacketout(ogg_stream_state *os,NvOggPacket *op); NvS32 NvOggStreamPacketpeek(ogg_stream_state *os,NvOggPacket *op); NvS32 NvOggPacketRelease(NvOggPacket *op); NvS32 NvOggPageRelease(ogg_page *og); void NvOggPageDup(ogg_page *dup,ogg_page *orig); NvS32 Nv0ggPageContinued(ogg_page *og); NvS32 NvOggPageEos(ogg_page *og); ogg_int64_t NvOggPageGranulepos(ogg_page *og); ogg_uint32_t NvOggPageSerialno(ogg_page *og); ogg_sync_state *NvOggSyncCreate(void); NvS32 NvOggSyncDestroy(ogg_sync_state *oy); NvU8 *NvOggSyncBufferin(ogg_sync_state *oy, NvS32 bytes); NvS32 NvOggSyncWrote(ogg_sync_state *oy, NvS32 bytes); NvS32 NvOggSyncReset(ogg_sync_state *oy); ogg_stream_state *NvOggStreamCreate(NvS32 serialno); NvS32 NvOggStreamDestroy(ogg_stream_state *os); NvS32 NvOggStreamDestroyEnd(ogg_stream_state *os); NvS32 NvOggStreamPagein(ogg_stream_state *os, ogg_page *og); NvS32 NvOggStreamReset(ogg_stream_state *os); NvS32 NvOggStreamResetSerialno(ogg_stream_state *os,NvS32 serialno);
5d1e012bc925f1dd457c430b001260c69504b0540cb8bfc8a9241d4aa024c29a
2,236
JianpingZeng
xcc
samples/Juliet/testcases/CWE321_Hard_Coded_Cryptographic_Key/CWE321_Hard_Coded_Cryptographic_Key__w32_char_53d.c
CWE321_Hard_Coded_Cryptographic_Key__w32_char_53d_goodG2BSink
void CWE321_Hard_Coded_Cryptographic_Key__w32_char_53d_goodG2BSink(char * cryptoKey) { { HCRYPTPROV hCryptProv; HCRYPTKEY hKey; HCRYPTHASH hHash; char toBeEncrypted[] = "String to be encrypted"; DWORD encryptedLen = strlen(toBeEncrypted)*sizeof(char); BYTE encrypted[200]; memcpy(encrypted, toBeEncrypted, encryptedLen); if(!CryptAcquireContext(&hCryptProv, NULL, MS_ENHANCED_PROV, PROV_RSA_AES, 0)) { if(!CryptAcquireContext(&hCryptProv, NULL, MS_ENHANCED_PROV, PROV_RSA_AES, CRYPT_NEWKEYSET)) { printLine("Error in acquiring cryptographic context"); exit(1); } } if(!CryptCreateHash(hCryptProv, CALG_SHA_256, 0, 0, &hHash)) { printLine("Error in creating hash"); exit(1); } if(!CryptHashData(hHash, (BYTE *) cryptoKey, strlen(cryptoKey)*sizeof(char), 0)) { printLine("Error in hashing cryptoKey"); exit(1); } if(!CryptDeriveKey(hCryptProv, CALG_AES_256, hHash, 0, &hKey)) { printLine("Error in CryptDeriveKey"); exit(1); } if(!CryptEncrypt(hKey, (HCRYPTHASH)NULL, 1, 0, encrypted, &encryptedLen, sizeof(encrypted))) { printLine("Error in CryptEncrypt"); exit(1); } printBytesLine(encrypted, encryptedLen); if (hKey) { CryptDestroyKey(hKey); } if (hHash) { CryptDestroyHash(hHash); } if (hCryptProv) { CryptReleaseContext(hCryptProv, 0); } } }
void CWE321_Hard_Coded_Cryptographic_Key__w32_char_53d_badSink(char * cryptoKey);
27139bf8b4b60dd2ad987ee2a9389ce6f5f6cbd40fca5a0ea1922d2604da502a
1,854
yzfcer
wind_os
src/core/wind_mutex.c
rent
rent(); if (!IS_F_MUTEX_LOCKED(mutex)) { SET_F_MUTEX_LOCKED(mutex); mutex->nest ++; mutex->owner = wind_thread_current(); wind_enable_switch(); return W_ERR_OK; } if(thread == mutex->owner) { if(mutex->nest < 65535) mutex->nest ++; wind_enable_switch(); return W_ERR_OK; } thread->runstat = THREAD_STATUS_SUSPEND; thread->cause = CAUSE_LOCK; thread->sleep_ticks = 0x7fffffff; dlist_insert_prio(&mutex->waitlist,&thread->suspendnode,thread->prio); wind_enable_switch(); _wind_thread_dispatch(); return W_ERR_OK; } w_err_t wind_mutex_trylock(w_mutex_s *mutex) { w_err_t err; WIND_ASSERT_RETURN(mutex != W_NULL,W_ERR_PTR_NULL); WIND_ASSERT_RETURN(mutex->obj.magic == WIND_MUTEX_MAGIC,W_ERR_INVALID); wind_disable_switch(); if (!IS_F_MUTEX_LOCKED(mu
w_err_t mutex_free(void *mutex); nit(void); ol,sizeof(mutexpool); init(w_mutex_s *mutex,const char *name); NULL,W_NULL); itch(); RN(err == W_ERR_OK, W_ERR_FAIL); ); nd_enable_switch();
82b09a48747cfc25e06c5067c6575f51719b02fd86ee7744581bae96b3a1613a
941
HarryR
ZeroDB
bench/db-bench.c
void db_test_pseudorandom
static void db_test_pseudorandom( benchmark_t* b ) { assert(b != NULL); run_test_rwmix(b, b->entries, bop_read_pseudorand, bop_write_pseudorand); }
DB_OP(count_value);
c9b46888075f7cba7dae7e003eb75afd9f4739c22bd1b402e729f3ff5622f530
150
Blackburn29
PsycoKernel
drivers/mfd/wm8350-core.c
wm8350_phys_read
static int wm8350_phys_read(struct wm8350 *wm8350, u8 reg, int num_regs, u16 *dest) { int i, ret; int bytes = num_regs * 2; dev_dbg(wm8350->dev, "volatile read\n"); ret = wm8350->read_dev(wm8350, reg, bytes, (char *)dest); for (i = reg; i < reg + num_regs; i++) { dest[i - reg] = be16_to_cpu(dest[i - reg]); dest[i - reg] &= wm8350_reg_io_map[i].readable; } dump(num_regs, dest); return ret; }
static int wm8350_read(struct wm8350 *wm8350, u8 reg, int num_regs, u16 *dest); static inline int is_reg_locked(struct wm8350 *wm8350, u8 reg); static int wm8350_write(struct wm8350 *wm8350, u8 reg, int num_regs, u16 *src); int wm8350_clear_bits(struct wm8350 *wm8350, u16 reg, u16 mask); int wm8350_set_bits(struct wm8350 *wm8350, u16 reg, u16 mask); u16 wm8350_reg_read(struct wm8350 *wm8350, int reg); int wm8350_reg_write(struct wm8350 *wm8350, int reg, u16 val); int wm8350_reg_lock(struct wm8350 *wm8350); int wm8350_reg_unlock(struct wm8350 *wm8350); int wm8350_read_auxadc(struct wm8350 *wm8350, int channel, int scale, int vref); static irqreturn_t wm8350_auxadc_irq(int irq, void *irq_data); static int wm8350_create_cache(struct wm8350 *wm8350, int type, int mode); void wm8350_device_exit(struct wm8350 *wm8350);
92875f24e69eac5ec43e6dbaf50cb343dd89ce77deaaac94774962999d2c0df9
424
CEG-ICRISAT
Raspberry
c/htslib-1.2.1/cram/cram_io.c
cram_uncompress_block
int cram_uncompress_block(cram_block *b) { char *uncomp; size_t uncomp_size = 0; if (b->uncomp_size == 0) { b->method = RAW; return 0; } switch (b->method) { case RAW: return 0; case GZIP: uncomp = zlib_mem_inflate((char *)b->data, b->comp_size, &uncomp_size); if (!uncomp) return -1; if ((int)uncomp_size != b->uncomp_size) { free(uncomp); return -1; } free(b->data); b->data = (unsigned char *)uncomp; b->alloc = uncomp_size; b->method = RAW; break; #ifdef HAVE_LIBBZ2 case BZIP2: { unsigned int usize = b->uncomp_size; if (!(uncomp = malloc(usize))) return -1; if (BZ_OK != BZ2_bzBuffToBuffDecompress(uncomp, &usize, (char *)b->data, b->comp_size, 0, 0)) { free(uncomp); return -1; } free(b->data); b->data = (unsigned char *)uncomp; b->alloc = usize; b->method = RAW; b->uncomp_size = usize; break; } #else case BZIP2: fprintf(stderr, "Bzip2 compression is not compiled into this " "version.\nPlease rebuild and try again.\n"); return -1; #endif #ifdef HAVE_LIBLZMA case LZMA: uncomp = lzma_mem_inflate((char *)b->data, b->comp_size, &uncomp_size); if (!uncomp) return -1; if ((int)uncomp_size != b->uncomp_size) return -1; free(b->data); b->data = (unsigned char *)uncomp; b->alloc = uncomp_size; b->method = RAW; break; #else case LZMA: fprintf(stderr, "Lzma compression is not compiled into this " "version.\nPlease rebuild and try again.\n"); return -1; break; #endif case RANS: { unsigned int usize = b->uncomp_size, usize2; uncomp = (char *)rans_uncompress(b->data, b->comp_size, &usize2); assert(usize == usize2); free(b->data); b->data = (unsigned char *)uncomp; b->alloc = usize2; b->method = RAW; b->uncomp_size = usize2; break; } default: return -1; } return 0; }
int itf8_decode(cram_fd *fd, int32_t *val_p); int itf8_encode(cram_fd *fd, int32_t val); int itf8_get(char *cp, int32_t *val_p); int itf8_put(char *cp, int32_t val); int ltf8_put(char *cp, int64_t val); int ltf8_get(char *cp, int64_t *val_p); int ltf8_decode(cram_fd *fd, int64_t *val_p); int itf8_put_blk(cram_block *blk, int val); int int32_decode(cram_fd *fd, int32_t *val); int int32_encode(cram_fd *fd, int32_t val); int int32_get(cram_block *b, int32_t *val); int int32_put(cram_block *b, int32_t val); char *zlib_mem_inflate(char *cdata, size_t csize, size_t *size); static char *lzma_mem_inflate(char *cdata, size_t csize, size_t *size); cram_block *cram_read_block(cram_fd *fd); int cram_write_block(cram_fd *fd, cram_block *b); void cram_free_block(cram_block *b); cram_metrics *cram_new_metrics(void); char *cram_block_method2str(enum cram_block_method m); char *cram_content_type2str(enum cram_content_type t); int paranoid_fclose(FILE *fp); void refs_free(refs_t *r); static refs_t *refs_create(void); static BGZF *bgzf_open_ref(char *fn, char *mode); static refs_t *refs_load_fai(refs_t *r_orig, char *fn, int is_err); int refs2id(refs_t *r, SAM_hdr *h); static int refs_from_header(refs_t *r, cram_fd *fd, SAM_hdr *h); int cram_set_header(cram_fd *fd, SAM_hdr *hdr); void expand_cache_path(char *path, char *dir, char *fn); void mkdir_prefix(char *path, int mode); static const char *get_cache_basedir(const char **extra); static int cram_populate_ref(cram_fd *fd, int id, ref_entry *r); static void cram_ref_incr_locked(refs_t *r, int id); void cram_ref_incr(refs_t *r, int id); static void cram_ref_decr_locked(refs_t *r, int id); void cram_ref_decr(refs_t *r, int id); static char *load_ref_portion(BGZF *fp, ref_entry *e, int start, int end); ref_entry *cram_ref_load(refs_t *r, int id); char *cram_get_ref(cram_fd *fd, int id, int start, int end); int cram_load_reference(cram_fd *fd, char *fn); cram_container *cram_new_container(int nrec, int nslice); void cram_free_container(cram_container *c); cram_container *cram_read_container(cram_fd *fd); int cram_write_container(cram_fd *fd, cram_container *c); static int cram_flush_container2(cram_fd *fd, cram_container *c); int cram_flush_container(cram_fd *fd, cram_container *c); void *cram_flush_thread(void *arg); static int cram_flush_result(cram_fd *fd); int cram_flush_container_mt(cram_fd *fd, cram_container *c); cram_block_compression_hdr *cram_new_compression_header(void); void cram_free_compression_header(cram_block_compression_hdr *hdr); void cram_free_slice_header(cram_block_slice_hdr *hdr); void cram_free_slice(cram_slice *s); cram_slice *cram_new_slice(enum cram_content_type type, int nrecs); cram_slice *cram_read_slice(cram_fd *fd); cram_file_def *cram_read_file_def(cram_fd *fd); int cram_write_file_def(cram_fd *fd, cram_file_def *def); void cram_free_file_def(cram_file_def *def); SAM_hdr *cram_read_SAM_hdr(cram_fd *fd); static void full_path(char *out, char *in); int cram_write_SAM_hdr(cram_fd *fd, SAM_hdr *hdr); static void cram_init_tables(cram_fd *fd); cram_fd *cram_open(const char *filename, const char *mode); cram_fd *cram_dopen(hFILE *fp, const char *filename, const char *mode); int cram_seek(cram_fd *fd, off_t offset, int whence); int cram_flush(cram_fd *fd); int cram_close(cram_fd *fd); int cram_eof(cram_fd *fd); int cram_set_option(cram_fd *fd, enum cram_option opt, ...); int cram_set_voption(cram_fd *fd, enum cram_option opt, va_list args);
542d30d1da9f411279d4e9bf0a699250efd0db01ae47d3ee5851de72ed7adfa2
1,866
AndreyPopovNew
asuswrt-merlin-rt-n
linux-2.6.22.19-cs543/scripts/mod/sumversion.c
cpu_to_le32_array
static inline void cpu_to_le32_array(uint32_t *buf, unsigned int words) { while (words--) { *buf = htonl(*buf); buf++; } }
static inline uint32_t lshift(uint32_t x, unsigned int s); static inline uint32_t F(uint32_t x, uint32_t y, uint32_t z); static inline uint32_t G(uint32_t x, uint32_t y, uint32_t z); static inline uint32_t H(uint32_t x, uint32_t y, uint32_t z); static inline void le32_to_cpu_array(uint32_t *buf, unsigned int words); static void md4_transform(uint32_t *hash, uint32_t const *in); static inline void md4_transform_helper(struct md4_ctx *ctx); static void md4_init(struct md4_ctx *mctx); static void md4_final_ascii(struct md4_ctx *mctx, char *out, unsigned int len); static inline void add_char(unsigned char c, struct md4_ctx *md); static int parse_comment(const char *file, unsigned long len); static int parse_file(const char *fname, struct md4_ctx *md); static int parse_source_files(const char *objfile, struct md4_ctx *md); void get_src_version(const char *modname, char sum[], unsigned sumlen); static int strip_rcs_crap(char *version);
8020fda37fb37cf8a1f01961b0e20ba7801a15990c01da6fd24126e09d11b6a6
129
matthiasbeyer
linux
drivers/mtd/nand/raw/omap2.c
omap_hwcontrol
atic void omap_hwcontrol(struct nand_chip *chip, int cmd, unsigned int ctrl) { struct omap_nand_info *info = mtd_to_omap(nand_to_mtd(chip)); if (cmd != NAND_CMD_NONE) { if (ctrl & NAND_CLE) writeb(cmd, info->reg.gpmc_nand_command); else if (ctrl & NAND_ALE) writeb(cmd, info->reg.gpmc_nand_address); else writeb(cmd, info->reg.gpmc_nand_data); } } /
atic inline struct omap_nand_info *mtd_to_omap(struct mtd_info *mtd); atic int omap_prefetch_enable(int cs, int fifo_th, int dma_mode, unsigned int u32_count, int is_write, struct omap_nand_info *info); atic int omap_prefetch_reset(int cs, struct omap_nand_info *info); atic void omap_read_buf8(struct mtd_info *mtd, u_char *buf, int len); atic void omap_write_buf8(struct mtd_info *mtd, const u_char *buf, int len); atic void omap_read_buf16(struct mtd_info *mtd, u_char *buf, int len); atic void omap_write_buf16(struct mtd_info *mtd, const u_char * buf, int len); atic void omap_read_buf_pref(struct nand_chip *chip, u_char *buf, int len); atic void omap_write_buf_pref(struct nand_chip *chip, const u_char *buf, int len); atic void omap_nand_dma_callback(void *data); atic inline int omap_nand_dma_transfer(struct mtd_info *mtd, void *addr, unsigned int len, int is_write); atic void omap_read_buf_dma_pref(struct nand_chip *chip, u_char *buf, int len); atic void omap_write_buf_dma_pref(struct nand_chip *chip, const u_char *buf, int len); atic irqreturn_t omap_nand_irq(int this_irq, void *dev); atic void omap_read_buf_irq_pref(struct nand_chip *chip, u_char *buf, int len); atic void omap_write_buf_irq_pref(struct nand_chip *chip, const u_char *buf, int len); atic void gen_true_ecc(u8 *ecc_buf); atic int omap_correct_data(struct nand_chip *chip, u_char *dat, u_char *read_ecc, u_char *calc_ecc); atic int omap_calculate_ecc(struct nand_chip *chip, const u_char *dat, u_char *ecc_code); atic void omap_enable_hwecc(struct nand_chip *chip, int mode); atic int omap_wait(struct nand_chip *this); atic int omap_dev_ready(struct nand_chip *chip); atic void __maybe_unused omap_enable_hwecc_bch(struct nand_chip *chip, int mode); atic int _omap_calculate_ecc_bch(struct mtd_info *mtd, const u_char *dat, u_char *ecc_calc, int i); atic int omap_calculate_ecc_bch_sw(struct nand_chip *chip, const u_char *dat, u_char *ecc_calc); atic int omap_calculate_ecc_bch_multi(struct mtd_info *mtd, const u_char *dat, u_char *ecc_calc); atic int erased_sector_bitflips(u_char *data, u_char *oob, struct omap_nand_info *info); atic int omap_elm_correct_data(struct nand_chip *chip, u_char *data, u_char *read_ecc, u_char *calc_ecc); atic int omap_write_page_bch(struct nand_chip *chip, const uint8_t *buf, int oob_required, int page); atic int omap_read_page_bch(struct nand_chip *chip, uint8_t *buf, int oob_required, int page); atic bool is_elm_present(struct omap_nand_info *info, struct device_node *elm_node); atic bool omap2_nand_ecc_check(struct omap_nand_info *info); atic int omap_get_dt_info(struct device *dev, struct omap_nand_info *info); atic int omap_ooblayout_ecc(struct mtd_info *mtd, int section, struct mtd_oob_region *oobregion); atic int omap_ooblayout_free(struct mtd_info *mtd, int section, struct mtd_oob_region *oobregion); atic int omap_sw_ooblayout_ecc(struct mtd_info *mtd, int section, struct mtd_oob_region *oobregion); atic int omap_sw_ooblayout_free(struct mtd_info *mtd, int section, struct mtd_oob_region *oobregion); atic int omap_nand_attach_chip(struct nand_chip *chip); atic int omap_nand_probe(struct platform_device *pdev); atic int omap_nand_remove(struct platform_device *pdev);
09354f928f23f6de5396c1f42100200a9388c23223192cae3cadac69f7831926
373
SNDBXIE
myway-eathena
src/map/battle.c
battle_getenemy
struct block_list* battle_getenemy(struct block_list *target, int type, int range) { struct block_list *bl_list[24]; int c = 0; memset(bl_list, 0, sizeof(bl_list)); map_foreachinrange(battle_getenemy_sub, target, range, type, bl_list, &c, target); if ( c == 0 ) return NULL; if( c > 24 ) c = 24; return bl_list[rnd()%c]; }
int battle_getcurrentskill(struct block_list *bl); static int battle_gettargeted_sub(struct block_list *bl, va_list ap); struct block_list* battle_gettargeted(struct block_list *target); int battle_gettarget(struct block_list* bl); static int battle_getenemy_sub(struct block_list *bl, va_list ap); static int battle_getenemyarea_sub(struct block_list *bl, va_list ap); struct block_list* battle_getenemyarea(struct block_list *src, int x, int y, int range, int type, int ignore_id); int battle_delay_damage_sub(int tid, unsigned int tick, int id, intptr_t data); int battle_delay_damage (unsigned int tick, int amotion, struct block_list *src, struct block_list *target, int attack_type, uint16 skill_id, uint16 skill_lv, int damage, enum damage_lv dmg_lv, int ddelay, bool additional_effects); int battle_attr_ratio(int atk_elem,int def_type, int def_lv); int battle_attr_fix(struct block_list *src, struct block_list *target, int damage,int atk_elem,int def_type, int def_lv); int battle_calc_cardfix(int attack_type, struct block_list *src, struct block_list *target, int nk, int s_ele, int s_ele_, int damage, int left, int flag); int battle_calc_damage(struct block_list *src,struct block_list *bl,struct Damage *d,int damage,uint16 skill_id,uint16 skill_lv); int battle_calc_bg_damage(struct block_list *src, struct block_list *bl, int damage, int div_, uint16 skill_id, uint16 skill_lv, int flag); int battle_calc_gvg_damage(struct block_list *src,struct block_list *bl,int damage,int div_,uint16 skill_id,uint16 skill_lv,int flag); static int battle_calc_drain(int damage, int rate, int per); int battle_addmastery(struct map_session_data *sd,struct block_list *target,int dmg,int type); static int battle_calc_base_damage(struct status_data *status, struct weapon_atk *wa, struct status_change *sc, unsigned short t_size, struct map_session_data *sd, int flag); void battle_consume_ammo(TBL_PC*sd, int skill, int lv); static int battle_blewcount_bonus(struct map_session_data *sd, uint16 skill_id); static int battle_SAD(struct map_session_data *sd, struct block_list *target, uint16 skill_id); static struct Damage battle_calc_weapon_attack(struct block_list *src,struct block_list *target,uint16 skill_id,uint16 skill_lv,int wflag); struct Damage battle_calc_magic_attack(struct block_list *src,struct block_list *target,uint16 skill_id,uint16 skill_lv,int mflag); struct Damage battle_calc_misc_attack(struct block_list *src,struct block_list *target,uint16 skill_id,uint16 skill_lv,int mflag); struct Damage battle_calc_attack(int attack_type,struct block_list *bl,struct block_list *target,uint16 skill_id,uint16 skill_lv,int count); int battle_calc_return_damage(struct block_list* bl, struct block_list *src, int *dmg, int flag, uint16 skill_id); void battle_drain(TBL_PC *sd, struct block_list *tbl, int rdamage, int ldamage, int race, int boss); int battle_damage_area( struct block_list *bl, va_list ap); enum damage_lv battle_weapon_attack(struct block_list* src, struct block_list* target, unsigned int tick, int flag); int battle_check_undead(int race,int element); struct block_list* battle_get_master(struct block_list *src); int battle_check_target( struct block_list *src, struct block_list *target,int flag); bool battle_check_range(struct block_list *src, struct block_list *bl, int range); void rAthena_report(char* date, char *time_c); static int rAthena_report_timer(int tid, unsigned int tick, int id, intptr_t data); int battle_set_value(const char* w1, const char* w2); int battle_get_value(const char* w1); void battle_set_defaults(); void battle_adjust_conf(); int battle_config_read(const char* cfgName); void do_init_battle(void); void do_final_battle(void);
fed3bbcafd7aed8508d8714f4c6c38c2cf3fc0093c4b6402755df468145f4b56
352

No dataset card yet

New: Create and edit this dataset card directly on the website!

Contribute a Dataset Card
Downloads last month
3
Add dataset card