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
|
|---|---|---|---|---|---|---|---|---|
dbalmain | ferret | c/src/index.c | mr_num_docs |
static int mr_num_docs(IndexReader *ir)
{
int i, num_docs;
mutex_lock(&ir->mutex);
if (MR(ir)->num_docs_cache == -1) {
const int mr_reader_cnt = MR(ir)->r_cnt;
MR(ir)->num_docs_cache = 0;
for (i = 0; i < mr_reader_cnt; i++) {
IndexReader *reader = MR(ir)->sub_readers[i];
MR(ir)->num_docs_cache += reader->num_docs(reader);
}
}
num_docs = MR(ir)->num_docs_cache;
mutex_unlock(&ir->mutex);
return num_docs;
} |
static char *u64_to_str36(char *buf, int buf_size, u64 u);
static u64 str36_to_u64(char *p);
static char *segfn_for_generation(char *buf, u64 generation);
static unsigned long co_hash(const void *key);
static int co_eq(const void *key1, const void *key2);
static void co_destroy(CacheObject *self);
Hash *co_hash_create();
static INLINE void fi_set_store(FieldInfo *fi, int store);
static INLINE void fi_set_index(FieldInfo *fi, int index);
static INLINE void fi_set_term_vector(FieldInfo *fi, int term_vector);
static void fi_check_params(int store, int index, int term_vector);
void fi_deref(FieldInfo *fi);
char *fi_to_s(FieldInfo *fi);
FieldInfo *fis_add_field(FieldInfos *fis, FieldInfo *fi);
FieldInfo *fis_get_field(FieldInfos *fis, Symbol name);
int fis_get_field_num(FieldInfos *fis, Symbol name);
FieldInfo *fis_get_or_add_field(FieldInfos *fis, Symbol name);
FieldInfo *fis_by_number(FieldInfos *fis, int num);
FieldInfos *fis_read(InStream *is);
void fis_write(FieldInfos *fis, OutStream *os);
static const char *fi_store_str(FieldInfo *fi);
static const char *fi_index_str(FieldInfo *fi);
static const char *fi_term_vector_str(FieldInfo *fi);
char *fis_to_s(FieldInfos *fis);
void fis_deref(FieldInfos *fis);
static bool fis_has_vectors(FieldInfos *fis);
SegmentInfo *si_new(char *name, int doc_cnt, Store *store);
static SegmentInfo *si_read(Store *store, InStream *is);
static void si_write(SegmentInfo *si, OutStream *os);
void si_deref(SegmentInfo *si);
bool si_has_deletions(SegmentInfo *si);
bool si_has_separate_norms(SegmentInfo *si);
void si_advance_norm_gen(SegmentInfo *si, int field_num);
static char *si_norm_file_name(SegmentInfo *si, char *buf, int field_num);
static void si_delete_files(SegmentInfo *si, FieldInfos *fis, Deleter *dlr);
static char *new_segment(i64 generation);
static void which_gen_i(const char *file_name, void *arg);
static void si_put(SegmentInfo *si, FILE *stream);
void sis_put(SegmentInfos *sis, FILE *stream);
i64 sis_current_segment_generation(Store *store);
char *sis_curr_seg_file_name(char *buf, Store *store);
SegmentInfos *sis_new(FieldInfos *fis);
SegmentInfo *sis_new_segment(SegmentInfos *sis, int doc_cnt, Store *store);
void sis_destroy(SegmentInfos *sis);
SegmentInfo *sis_add_si(SegmentInfos *sis, SegmentInfo *si);
void sis_del_at(SegmentInfos *sis, int at);
void sis_del_from_to(SegmentInfos *sis, int from, int to);
void sis_clear(SegmentInfos *sis);
static void sis_read_i(Store *store, FindSegmentsFile *fsf);
SegmentInfos *sis_read(Store *store);
void sis_write(SegmentInfos *sis, Store *store, Deleter *deleter);
static void sis_read_ver_i(Store *store, FindSegmentsFile *fsf);
u64 sis_read_current_version(Store *store);
static void lazy_df_destroy(LazyDocField *self);
static void zraise(int ret);
static char *is_read_zipped_bytes(InStream *is, int zip_len, int *len);
static void zraise(int ret);
void bz_internal_error(int errcode);
static char *is_read_zipped_bytes(InStream *is, int zip_len, int *len);
char *lazy_df_get_data(LazyDocField *self, int i);
void lazy_df_get_bytes(LazyDocField *self, char *buf, int start, int len);
static LazyDoc *lazy_doc_new(int size, InStream *fdt_in);
void lazy_doc_close(LazyDoc *self);
static void lazy_doc_add_field(LazyDoc *self, LazyDocField *lazy_df, int i);
LazyDocField *frt_lazy_doc_get(LazyDoc *self, Symbol field);
FieldsReader *fr_open(Store *store, const char *segment, FieldInfos *fis);
FieldsReader *fr_clone(FieldsReader *orig);
void fr_close(FieldsReader *fr);
static DocField *fr_df_new(Symbol name, int size, bool is_compressed);
static void fr_read_zipped_fields(FieldsReader *fr, DocField *df);
Document *fr_get_doc(FieldsReader *fr, int doc_num);
LazyDoc *fr_get_lazy_doc(FieldsReader *fr, int doc_num);
static TermVector *fr_read_term_vector(FieldsReader *fr, int field_num);
Hash *fr_get_tv(FieldsReader *fr, int doc_num);
TermVector *fr_get_field_tv(FieldsReader *fr, int doc_num, int field_num);
FieldsWriter *fw_open(Store *store, const char *segment, FieldInfos *fis);
void fw_close(FieldsWriter *fw);
static int os_write_zipped_bytes(OutStream* out_stream, uchar *data, int length);
static int os_write_zipped_bytes(OutStream* out_stream, uchar *data, int length);
void fw_add_doc(FieldsWriter *fw, Document *doc);
void fw_write_tv_index(FieldsWriter *fw);
char *te_get_term(TermEnum *te);
TermInfo *te_get_ti(TermEnum *te);
static char *te_skip_to(TermEnum *te, const char *term);
static void sti_destroy(SegmentTermIndex *sti);
static int sti_get_index_offset(SegmentTermIndex *sti, const char *term);
SegmentFieldIndex *sfi_open(Store *store, const char *segment);
void sfi_close(SegmentFieldIndex *sfi);
static INLINE int term_read(char *buf, InStream *is);
static char *ste_next(TermEnum *te);
static void ste_reset(TermEnum *te);
static TermEnum *ste_set_field(TermEnum *te, int field_num);
static void ste_index_seek(TermEnum *te, SegmentTermIndex *sti, int idx_offset);
static char *ste_scan_to(TermEnum *te, const char *term);
static SegmentTermEnum *ste_allocate();
TermEnum *ste_clone(TermEnum *other_te);
void ste_close(TermEnum *te);
static char *ste_get_term(TermEnum *te, int pos);
TermEnum *ste_new(InStream *is, SegmentFieldIndex *sfi);
static bool tew_lt(const TermEnumWrapper *tew1, const TermEnumWrapper *tew2);
static char *tew_next(TermEnumWrapper *tew);
static char *tew_skip_to(TermEnumWrapper *tew, const char *term);
static void tew_destroy(TermEnumWrapper *tew);
static char *mte_next(TermEnum *te);
static TermEnum *mte_set_field(TermEnum *te, int field_num);
static char *mte_skip_to(TermEnum *te, const char *term);
static void mte_close(TermEnum *te);
TermEnum *mte_new(MultiReader *mr, int field_num, const char *term);
static INLINE TermEnum *tir_enum(TermInfosReader *tir);
TermInfosReader *tir_set_field(TermInfosReader *tir, int field_num);
TermInfo *tir_get_ti(TermInfosReader *tir, const char *term);
char *tir_get_term(TermInfosReader *tir, int pos);
void tir_close(TermInfosReader *tir);
static TermWriter *tw_new(Store *store, char *file_name);
static void tw_close(TermWriter *tw);
static INLINE void tw_reset(TermWriter *tw);
void tiw_start_field(TermInfosWriter *tiw, int field_num);
void tiw_close(TermInfosWriter *tiw);
static void stde_seek_ti(SegmentTermDocEnum *stde, TermInfo *ti);
static void stde_seek(TermDocEnum *tde, int field_num, const char *term);
static void stde_seek_te(TermDocEnum *tde, TermEnum *te);
static int stde_doc_num(TermDocEnum *tde);
static int stde_freq(TermDocEnum *tde);
static bool stde_next(TermDocEnum *tde);
static int stde_read(TermDocEnum *tde, int *docs, int *freqs, int req_num);
static bool stde_skip_to(TermDocEnum *tde, int target_doc_num);
static void stde_close(TermDocEnum *tde);
static void stde_skip_prox(SegmentTermDocEnum *stde);
static void stde_seek_prox(SegmentTermDocEnum *stde, off_t prx_ptr);
static void stpe_seek_ti(SegmentTermDocEnum *stde, TermInfo *ti);
static void stpe_seek(TermDocEnum *tde, int field_num, const char *term);
static bool stpe_next(TermDocEnum *tde);
static int stpe_read(TermDocEnum *tde, int *docs, int *freqs, int req_num);
static int stpe_next_position(TermDocEnum *tde);
static void stpe_close(TermDocEnum *tde);
static void stpe_skip_prox(SegmentTermDocEnum *stde);
static void stpe_seek_prox(SegmentTermDocEnum *stde, off_t prx_ptr);
static TermDocEnum *mtde_next_tde(MultiTermDocEnum *mtde);
static void mtde_seek_te(TermDocEnum *tde, TermEnum *te);
static void mtde_seek(TermDocEnum *tde, int field_num, const char *term);
static int mtde_doc_num(TermDocEnum *tde);
static int mtde_freq(TermDocEnum *tde);
static bool mtde_next(TermDocEnum *tde);
static int mtde_read(TermDocEnum *tde, int *docs, int *freqs, int req_num);
static bool mtde_skip_to(TermDocEnum *tde, int target_doc_num);
static void mtde_close(TermDocEnum *tde);
static TermDocEnum *mtxe_new(MultiReader *mr);
static TermDocEnum *mtde_new(MultiReader *mr);
static int mtpe_next_position(TermDocEnum *tde);
static TermDocEnum *mtpe_new(MultiReader *mr);
static void tde_destroy(TermDocEnum *tde);
static void mtdpe_seek(TermDocEnum *tde, int field_num, const char *term);
static int mtdpe_doc_num(TermDocEnum *tde);
static int mtdpe_freq(TermDocEnum *tde);
static bool mtdpe_next(TermDocEnum *tde);
static bool tdpe_less_than(TermDocEnum *p1, TermDocEnum *p2);
static bool mtdpe_skip_to(TermDocEnum *tde, int target_doc_num);
static int mtdpe_read(TermDocEnum *tde, int *docs, int *freqs, int req_num);
static int mtdpe_next_position(TermDocEnum *tde);
static void mtdpe_close(TermDocEnum *tde);
TermDocEnum *mtdpe_new(IndexReader *ir, int field_num, char **terms, int t_cnt);
static void file_name_filter_init();
bool file_name_filter_is_index_file(const char *file_name, bool include_locks);
static bool file_name_filter_is_cfs_file(const char *file_name);
Deleter *deleter_new(SegmentInfos *sis, Store *store);
void deleter_destroy(Deleter *dlr);
static void deleter_queue_file(Deleter *dlr, const char *file_name);
void deleter_delete_file(Deleter *dlr, char *file_name);
static void deleter_commit_pending_deletions(Deleter *dlr);
void deleter_delete_files(Deleter *dlr, char **files, int file_cnt);
static void deleter_find_deletable_files_i(const char *file_name, void *arg);
void deleter_find_deletable_files(Deleter *dlr);
static void deleter_delete_deletable_files(Deleter *dlr);
static void ir_acquire_not_necessary(IndexReader *ir);
static void ir_acquire_write_lock(IndexReader *ir);
bool ir_index_exists(Store *store);
int ir_get_field_num(IndexReader *ir, Symbol field);
int ir_doc_freq(IndexReader *ir, Symbol field, const char *term);
static void ir_set_norm_i(IndexReader *ir, int doc_num, int field_num, uchar val);
void ir_set_norm(IndexReader *ir, int doc_num, Symbol field, uchar val);
uchar *ir_get_norms_i(IndexReader *ir, int field_num);
uchar *ir_get_norms(IndexReader *ir, Symbol field);
uchar *ir_get_norms_into(IndexReader *ir, Symbol field, uchar *buf);
void ir_undelete_all(IndexReader *ir);
void ir_delete_doc(IndexReader *ir, int doc_num);
TermEnum *ir_terms(IndexReader *ir, Symbol field);
static void ir_commit_i(IndexReader *ir);
void ir_commit(IndexReader *ir);
void ir_close(IndexReader *ir);
void ir_add_cache(IndexReader *ir);
bool ir_is_latest(IndexReader *ir);
static Norm *norm_create(InStream *is, int field_num);
static void norm_destroy(Norm *norm);
static INLINE FieldsReader *sr_fr(SegmentReader *sr);
static INLINE bool sr_is_deleted_i(SegmentReader *sr, int doc_num);
static INLINE uchar *sr_get_norms_i(SegmentReader *sr, int field_num);
static void sr_set_norm_i(IndexReader *ir, int doc_num, int field_num, uchar b);
static void sr_delete_doc_i(IndexReader *ir, int doc_num);
static void sr_undelete_all_i(IndexReader *ir);
static void sr_set_deleter_i(IndexReader *ir, Deleter *deleter);
static void bv_write(BitVector *bv, Store *store, char *name);
static BitVector *bv_read(Store *store, char *name);
static bool sr_is_latest_i(IndexReader *ir);
static void sr_commit_i(IndexReader *ir);
static void sr_close_i(IndexReader *ir);
static int sr_num_docs(IndexReader *ir);
static int sr_max_doc(IndexReader *ir);
static Document *sr_get_doc(IndexReader *ir, int doc_num);
static LazyDoc *sr_get_lazy_doc(IndexReader *ir, int doc_num);
static uchar *sr_get_norms(IndexReader *ir, int field_num);
static TermEnum *sr_terms(IndexReader *ir, int field_num);
static TermEnum *sr_terms_from(IndexReader *ir, int field_num, const char *term);
static int sr_doc_freq(IndexReader *ir, int field_num, const char *term);
static TermDocEnum *sr_term_docs(IndexReader *ir);
static TermDocEnum *sr_term_positions(IndexReader *ir);
static Hash *sr_term_vectors(IndexReader *ir, int doc_num);
static bool sr_is_deleted(IndexReader *ir, int doc_num);
static bool sr_has_deletions(IndexReader *ir);
static void sr_open_norms(IndexReader *ir, Store *cfs_store);
static IndexReader *sr_setup_i(SegmentReader *sr);
static int mr_reader_index_i(MultiReader *mr, int doc_num);
static int mr_max_doc(IndexReader *ir);
static Document *mr_get_doc(IndexReader *ir, int doc_num);
static LazyDoc *mr_get_lazy_doc(IndexReader *ir, int doc_num);
int mr_get_field_num(MultiReader *mr, int ir_num, int f_num);
static uchar *mr_get_norms(IndexReader *ir, int field_num);
static uchar *mr_get_norms_into(IndexReader *ir, int field_num, uchar *buf);
static TermEnum *mr_terms(IndexReader *ir, int field_num);
static TermEnum *mr_terms_from(IndexReader *ir, int field_num, const char *term);
static int mr_doc_freq(IndexReader *ir, int field_num, const char *t);
static TermDocEnum *mr_term_docs(IndexReader *ir);
static TermDocEnum *mr_term_positions(IndexReader *ir);
static Hash *mr_term_vectors(IndexReader *ir, int doc_num);
static bool mr_is_deleted(IndexReader *ir, int doc_num);
static bool mr_has_deletions(IndexReader *ir);
static void mr_set_norm_i(IndexReader *ir, int doc_num, int field_num, uchar val);
static void mr_delete_doc_i(IndexReader *ir, int doc_num);
static void mr_undelete_all_i(IndexReader *ir);
static void mr_set_deleter_i(IndexReader *ir, Deleter *deleter);
static bool mr_is_latest_i(IndexReader *ir);
static void mr_commit_i(IndexReader *ir);
static void mr_close_i(IndexReader *ir);
static IndexReader *mr_new(IndexReader **sub_readers, const int r_cnt);
static void mr_close_ext_i(IndexReader *ir);
IndexReader *mr_open(IndexReader **sub_readers, const int r_cnt);
static void ir_open_i(Store *store, FindSegmentsFile *fsf);
| 9cc09e386f9768c7b491e1c57ed6f6bc01e210274697eabaf1870a6c788e9fea | 493 |
|
cnvogelg | plip2slip | src/plip_rx.c | end_rx |
static u08 end_rx(plip_packet_t *pkt)
{
slip_send_end();
return PLIP_STATUS_OK;
} |
static u08 begin_rx(plip_packet_t *pkt);
static u08 fill_rx(u08 *data);
static u08 fake_rx(plip_packet_t *pkt);
static u08 fake_fill_rx(u08 *data);
void plip_rx_init(void);
u08 plip_rx_worker(void);
| fffbf4e83a4d90c540ae3112c06ee5660d889dbdda6f5e0b6858aeb4cdea540d | 86 |
|
SlimRoms | kernel_cyanogen_msm8916 | drivers/media/platform/msm/camera_v2/sensor/msm_sensor.c | msm_sensor_platform_probe |
int32_t msm_sensor_platform_probe(struct platform_device *pdev,
const void *data)
{
int rc = 0;
struct msm_sensor_ctrl_t *s_ctrl =
(struct msm_sensor_ctrl_t *)data;
struct msm_camera_cci_client *cci_client = NULL;
uint32_t session_id;
unsigned long mount_pos = 0;
s_ctrl->pdev = pdev;
CDBG("%s called data %pK\n", __func__, data);
CDBG("%s pdev name %s\n", __func__, pdev->id_entry->name);
if (pdev->dev.of_node) {
rc = msm_sensor_get_dt_data(pdev->dev.of_node, s_ctrl);
if (rc < 0) {
pr_err("%s failed line %d\n", __func__, __LINE__);
return rc;
}
}
s_ctrl->sensordata->power_info.dev = &pdev->dev;
s_ctrl->sensor_device_type = MSM_CAMERA_PLATFORM_DEVICE;
s_ctrl->sensor_i2c_client->cci_client = kzalloc(sizeof(
struct msm_camera_cci_client), GFP_KERNEL);
if (!s_ctrl->sensor_i2c_client->cci_client) {
pr_err("%s failed line %d\n", __func__, __LINE__);
return rc;
}
cci_client = s_ctrl->sensor_i2c_client->cci_client;
cci_client->cci_subdev = msm_cci_get_subdev();
cci_client->cci_i2c_master = s_ctrl->cci_i2c_master;
cci_client->sid =
s_ctrl->sensordata->slave_info->sensor_slave_addr >> 1;
cci_client->retries = 3;
cci_client->id_map = 0;
if (!s_ctrl->func_tbl)
s_ctrl->func_tbl = &msm_sensor_func_tbl;
if (!s_ctrl->sensor_i2c_client->i2c_func_tbl)
s_ctrl->sensor_i2c_client->i2c_func_tbl =
&msm_sensor_cci_func_tbl;
if (!s_ctrl->sensor_v4l2_subdev_ops)
s_ctrl->sensor_v4l2_subdev_ops = &msm_sensor_subdev_ops;
s_ctrl->sensordata->power_info.clk_info =
kzalloc(sizeof(cam_8974_clk_info), GFP_KERNEL);
if (!s_ctrl->sensordata->power_info.clk_info) {
pr_err("%s:%d failed nomem\n", __func__, __LINE__);
kfree(cci_client);
return -ENOMEM;
}
memcpy(s_ctrl->sensordata->power_info.clk_info, cam_8974_clk_info,
sizeof(cam_8974_clk_info));
s_ctrl->sensordata->power_info.clk_info_size =
ARRAY_SIZE(cam_8974_clk_info);
rc = s_ctrl->func_tbl->sensor_power_up(s_ctrl);
if (rc < 0) {
pr_err("%s %s power up failed\n", __func__,
s_ctrl->sensordata->sensor_name);
kfree(s_ctrl->sensordata->power_info.clk_info);
kfree(cci_client);
return rc;
}
pr_info("%s %s probe succeeded\n", __func__,
s_ctrl->sensordata->sensor_name);
v4l2_subdev_init(&s_ctrl->msm_sd.sd,
s_ctrl->sensor_v4l2_subdev_ops);
snprintf(s_ctrl->msm_sd.sd.name,
sizeof(s_ctrl->msm_sd.sd.name), "%s",
s_ctrl->sensordata->sensor_name);
v4l2_set_subdevdata(&s_ctrl->msm_sd.sd, pdev);
s_ctrl->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
media_entity_init(&s_ctrl->msm_sd.sd.entity, 0, NULL, 0);
s_ctrl->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
s_ctrl->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_SENSOR;
s_ctrl->msm_sd.sd.entity.name =
s_ctrl->msm_sd.sd.name;
mount_pos = s_ctrl->sensordata->sensor_info->position << 16;
mount_pos = mount_pos | ((s_ctrl->sensordata->sensor_info->
sensor_mount_angle / 90) << 8);
s_ctrl->msm_sd.sd.entity.flags = mount_pos | MEDIA_ENT_FL_DEFAULT;
rc = camera_init_v4l2(&s_ctrl->pdev->dev, &session_id);
CDBG("%s rc %d session_id %d\n", __func__, rc, session_id);
s_ctrl->sensordata->sensor_info->session_id = session_id;
s_ctrl->msm_sd.close_seq = MSM_SD_CLOSE_2ND_CATEGORY | 0x3;
msm_sd_register(&s_ctrl->msm_sd);
msm_sensor_v4l2_subdev_fops = v4l2_subdev_fops;
#ifdef CONFIG_COMPAT
msm_sensor_v4l2_subdev_fops.compat_ioctl32 =
msm_sensor_subdev_fops_ioctl;
#endif
s_ctrl->msm_sd.sd.devnode->fops =
&msm_sensor_v4l2_subdev_fops;
CDBG("%s:%d\n", __func__, __LINE__);
s_ctrl->func_tbl->sensor_power_down(s_ctrl);
CDBG("%s:%d\n", __func__, __LINE__);
return rc;
} |
uint32_t get_camera_id(void);
static void msm_sensor_adjust_mclk(struct msm_camera_power_ctrl_t *ctrl);
int32_t msm_sensor_free_sensor_data(struct msm_sensor_ctrl_t *s_ctrl);
int msm_sensor_power_down(struct msm_sensor_ctrl_t *s_ctrl);
int msm_sensor_power_up(struct msm_sensor_ctrl_t *s_ctrl);
int msm_sensor_match_id(struct msm_sensor_ctrl_t *s_ctrl);
static struct msm_sensor_ctrl_t *get_sctrl(struct v4l2_subdev *sd);
static void msm_sensor_stop_stream(struct msm_sensor_ctrl_t *s_ctrl);
int msm_sensor_config(struct msm_sensor_ctrl_t *s_ctrl, void __user *argp);
int msm_sensor_check_id(struct msm_sensor_ctrl_t *s_ctrl);
static int msm_sensor_power(struct v4l2_subdev *sd, int on);
bool msm_sensor_is_probed(int position);
int32_t msm_sensor_init_default_params(struct msm_sensor_ctrl_t *s_ctrl);
| 1382894683b713a2a5efa9ecde27907197d8d5d7b7c7e2332bfa8dcaad8a9289 | 3,601 |
|
Scheiker | RetroArch | configuration.c | *config_get_default_audio_resampler | nst char *config_get_default_audio_resampler(void)
{
enum audio_resampler_driver_enum default_driver = AUDIO_DEFAULT_RESAMPLER_DRIVER;
switch (default_driver)
{
case AUDIO_RESAMPLER_CC:
return "cc";
case AUDIO_RESAMPLER_SINC:
return "sinc";
case AUDIO_RESAMPLER_NEAREST:
return "nearest";
case AUDIO_RESAMPLER_NULL:
break;
}
return "null";
}
/ | ttings_t *config_get_ptr(void);
id config_free(void);
ol config_init(void);
nst char *config_get_default_audio(void);
nst char *config_get_default_record(void);
nst char *config_get_default_video(void);
nst char *config_get_default_input(void);
nst char *config_get_default_joypad(void);
nst char *config_get_default_camera(void);
nst char *config_get_default_wifi(void);
nst char *config_get_default_location(void);
nst char *config_get_default_menu(void);
ol config_overlay_enable_default(void);
atic struct config_array_setting *populate_settings_array(settings_t *settings, int *size);
atic struct config_path_setting *populate_settings_path(settings_t *settings, int *size);
atic struct config_bool_setting *populate_settings_bool(settings_t *settings, int *size);
atic struct config_float_setting *populate_settings_float(settings_t *settings, int *size);
atic struct config_uint_setting *populate_settings_uint(settings_t *settings, int *size);
atic struct config_int_setting *populate_settings_int(settings_t *settings, int *size);
atic void config_set_defaults(void);
atic config_file_t *open_default_config_file(void);
atic void read_keybinds_keyboard(config_file_t *conf, unsigned user,
unsigned idx, struct retro_keybind *bind);
atic void read_keybinds_button(config_file_t *conf, unsigned user,
unsigned idx, struct retro_keybind *bind);
atic void read_keybinds_axis(config_file_t *conf, unsigned user,
unsigned idx, struct retro_keybind *bind);
atic void read_keybinds_user(config_file_t *conf, unsigned user);
atic void config_read_keybinds_conf(config_file_t *conf);
atic bool check_shader_compatibility(enum file_path_enum enum_idx);
atic bool config_read_keybinds(const char *path);
atic void config_file_dump_all(config_file_t *conf);
atic void config_get_hex_base(config_file_t *conf,
const char *key, unsigned *base);
ol config_load_override(void);
ol config_unload_override(void);
ol config_load_remap(void);
ol config_load_shader_preset(void);
atic void parse_config_file(void);
atic void save_keybind_key(config_file_t *conf, const char *prefix,
const char *base, const struct retro_keybind *bind);
atic void save_keybind_hat(config_file_t *conf, const char *key,
const struct retro_keybind *bind);
atic void save_keybind_joykey(config_file_t *conf, const char *prefix,
const char *base, const struct retro_keybind *bind, bool save_empty);
atic void save_keybind_axis(config_file_t *conf, const char *prefix,
const char *base, const struct retro_keybind *bind, bool save_empty);
atic void save_keybinds_user(config_file_t *conf, unsigned user);
id config_load(void);
atic bool config_save_keybinds_file(const char *path);
ol config_save_autoconf_profile(const char *path, unsigned user);
ol config_save_file(const char *path);
ol config_save_overrides(int override_type);
ol config_replace(bool config_save_on_exit, char *path);
| 5c185919a4343e505ccf4caee3bb929c66fba5bb782206893fe0d7e7982b9336 | 421 |
|
amitkr | systemtap | testsuite/systemtap.base/sdt.c | call11 |
static void call11(int a, int b, int c, int d, int e, int f, int g, int h, int i, int j, int k)
{
STAP_PROBE11(test, mark_k, a, b, c, d, e, f, g, h, i, j, k);
} |
static void call0(void);
static void call1(int a);
static void call2(int a, int b);
static void call3(int a, int b, int c);
static void call4(int a, int b, int c, int d);
static void call5(int a, int b, int c, int d, int e);
static void call6(int a, int b, int c, int d, int e, int f);
static void call7(int a, int b, int c, int d, int e, int f, int g);
static void call8(int a, int b, int c, int d, int e, int f, int g, int h);
static void call9(int a, int b, int c, int d, int e, int f, int g, int h, int i);
static void call10(int a, int b, int c, int d, int e, int f, int g, int h, int i, int j);
static void call12(int a, int b, int c, int d, int e, int f, int g, int h, int i, int j, int k, int l);
| 965002b32ec4801a06f4b71d2c3b68e9ed030fead129ab08e1c45694b835c158 | 163 |
|
montsuqi | panda | libs/auth.c | AuthDelUser |
extern void AuthDelUser(char *name) {
PassWord *pw;
if ((pw = g_hash_table_lookup(PasswdTable, name)) != NULL) {
g_hash_table_remove(PasswdTable, name);
*pw->name = 0;
}
} |
extern const char *AuthMakeSalt(void);
extern void AuthClearEntry(void);
extern void AuthAddEntry(PassWord *pw);
extern void AuthAddUser(char *name, char *pass, int gid, int uid, char *other);
extern PassWord *AuthAuthUser(char *name, char *pass);
extern PassWord *AuthGetUser(char *name);
static Bool scan_passwd_entry(const char *buf, PassWord *pw);
extern void AuthLoadPasswd(char *fname);
extern Bool AuthSingle(char *fname, char *name, char *pass, char *other);
extern void AuthSavePasswd(char *fname);
static void CheckMax(char *name, PassWord *pwd, void *data);
extern int AuthMaxUID(void);
| 32d7dc9e6075de02800cfb03ef4f42f45ae64ff0876e2cbed00d6779d3b82b6a | 187 |
|
Distrotech | tigervnc | unix/Xvnc/programs/Xserver/present/present_notify.c | void
present_destroy_notifies | void
present_destroy_notifies(present_notify_ptr notifies, int num_notifies)
{
int i;
for (i = 0; i < num_notifies; i++)
present_free_window_notify(¬ifies[i]);
free(notifies);
}
| void
present_clear_window_notifies(WindowPtr window);
void
present_free_window_notify(present_notify_ptr notify);
int
present_add_window_notify(present_notify_ptr notify);
int
present_create_notifies(ClientPtr client, int num_notifies, xPresentNotify *x_notifies, present_notify_ptr *p_notifies);
| ad2b9c3b4d41ea5d240a83274d0b24fa689946da2811234546fed00b0c6dfac6 | 202 |
|
tasn | enlightenment | src/modules/pager/e_mod_main.c | void
_pager_cb_obj_hide |
static void
_pager_cb_obj_hide(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Instance *inst = data;
Eina_List *l;
Pager_Desk *pd;
EINA_LIST_FOREACH(inst->pager->desks, l, pd)
edje_object_signal_emit(pd->o_desk, "e,state,hidden", "e");
} | 82a8a59776120e6cceb97d078bda5d6f07dfbaa9d6676d1ae8f8d50cfcbcf487 | 310 |
||
williamfdevine | PrettyLinux | drivers/media/radio/wl128x/fmdrv_rx.c | fm_rx_set_region |
int fm_rx_set_region(struct fmdev *fmdev, u8 region_to_set)
{
u16 payload;
u32 new_frq = 0;
int ret;
if (region_to_set != FM_BAND_EUROPE_US &&
region_to_set != FM_BAND_JAPAN)
{
fmerr("Invalid band\n");
return -EINVAL;
}
if (fmdev->rx.region.fm_band == region_to_set)
{
fmerr("Requested band is already configured\n");
return 0;
}
payload = (u16)region_to_set;
ret = fmc_send_cmd(fmdev, BAND_SET, REG_WR, &payload,
sizeof(payload), NULL, NULL);
if (ret < 0)
{
return ret;
}
fmc_update_region_info(fmdev, region_to_set);
if (fmdev->rx.freq < fmdev->rx.region.bot_freq)
{
new_frq = fmdev->rx.region.bot_freq;
}
else if (fmdev->rx.freq > fmdev->rx.region.top_freq)
{
new_frq = fmdev->rx.region.top_freq;
}
if (new_frq)
{
fmdbg("Current freq is not within band limit boundary,"
"switching to %d KHz\n", new_frq);
ret = fm_rx_set_freq(fmdev, new_frq);
}
return ret;
} |
void fm_rx_reset_rds_cache(struct fmdev *fmdev);
void fm_rx_reset_station_info(struct fmdev *fmdev);
int fm_rx_set_freq(struct fmdev *fmdev, u32 freq);
static int fm_rx_set_channel_spacing(struct fmdev *fmdev, u32 spacing);
int fm_rx_set_volume(struct fmdev *fmdev, u16 vol_to_set);
int fm_rx_get_volume(struct fmdev *fmdev, u16 *curr_vol);
int fm_rx_get_band_freq_range(struct fmdev *fmdev, u32 *bot_freq, u32 *top_freq);
void fm_rx_get_region(struct fmdev *fmdev, u8 *region);
int fm_rx_get_mute_mode(struct fmdev *fmdev, u8 *curr_mute_mode);
static int fm_config_rx_mute_reg(struct fmdev *fmdev);
int fm_rx_set_mute_mode(struct fmdev *fmdev, u8 mute_mode_toset);
int fm_rx_get_rfdepend_softmute(struct fmdev *fmdev, u8 *curr_mute_mode);
int fm_rx_set_rfdepend_softmute(struct fmdev *fmdev, u8 rfdepend_mute);
int fm_rx_get_rssi_level(struct fmdev *fmdev, u16 *rssilvl);
int fm_rx_set_rssi_threshold(struct fmdev *fmdev, short rssi_lvl_toset);
int fm_rx_get_rssi_threshold(struct fmdev *fmdev, short *curr_rssi_lvl);
int fm_rx_set_stereo_mono(struct fmdev *fmdev, u16 mode);
int fm_rx_get_stereo_mono(struct fmdev *fmdev, u16 *mode);
int fm_rx_set_deemphasis_mode(struct fmdev *fmdev, u16 mode);
int fm_rx_get_deemph_mode(struct fmdev *fmdev, u16 *curr_deemphasis_mode);
int fm_rx_set_rds_mode(struct fmdev *fmdev, u8 rds_en_dis);
int fm_rx_get_rds_mode(struct fmdev *fmdev, u8 *curr_rds_en_dis);
int fm_rx_set_rds_system(struct fmdev *fmdev, u8 rds_mode);
int fm_rx_set_af_switch(struct fmdev *fmdev, u8 af_mode);
int fm_rx_get_af_switch(struct fmdev *fmdev, u8 *af_mode);
| ef357ce2ed7bd59633373f92ef6e1423256c492ac67eef23a3433ccaeab62a39 | 938 |
|
libos-nuse | net-next-nuse | drivers/net/wireless/ath/ath10k/core.c | *ath10k_core_create |
struct ath10k *ath10k_core_create(size_t priv_size, struct device *dev,
enum ath10k_bus bus,
enum ath10k_hw_rev hw_rev,
const struct ath10k_hif_ops *hif_ops)
{
struct ath10k *ar;
int ret;
ar = ath10k_mac_create(priv_size);
if (!ar)
return NULL;
ar->ath_common.priv = ar;
ar->ath_common.hw = ar->hw;
ar->dev = dev;
ar->hw_rev = hw_rev;
ar->hif.ops = hif_ops;
ar->hif.bus = bus;
switch (hw_rev) {
case ATH10K_HW_QCA988X:
case ATH10K_HW_QCA9887:
ar->regs = &qca988x_regs;
ar->hw_values = &qca988x_values;
break;
case ATH10K_HW_QCA6174:
case ATH10K_HW_QCA9377:
ar->regs = &qca6174_regs;
ar->hw_values = &qca6174_values;
break;
case ATH10K_HW_QCA99X0:
case ATH10K_HW_QCA9984:
ar->regs = &qca99x0_regs;
ar->hw_values = &qca99x0_values;
break;
case ATH10K_HW_QCA4019:
ar->regs = &qca4019_regs;
ar->hw_values = &qca4019_values;
break;
default:
ath10k_err(ar, "unsupported core hardware revision %d\n",
hw_rev);
ret = -ENOTSUPP;
goto err_free_mac;
}
init_completion(&ar->scan.started);
init_completion(&ar->scan.completed);
init_completion(&ar->scan.on_channel);
init_completion(&ar->target_suspend);
init_completion(&ar->wow.wakeup_completed);
init_completion(&ar->install_key_done);
init_completion(&ar->vdev_setup_done);
init_completion(&ar->thermal.wmi_sync);
init_completion(&ar->bss_survey_done);
INIT_DELAYED_WORK(&ar->scan.timeout, ath10k_scan_timeout_work);
ar->workqueue = create_singlethread_workqueue("ath10k_wq");
if (!ar->workqueue)
goto err_free_mac;
ar->workqueue_aux = create_singlethread_workqueue("ath10k_aux_wq");
if (!ar->workqueue_aux)
goto err_free_wq;
mutex_init(&ar->conf_mutex);
spin_lock_init(&ar->data_lock);
spin_lock_init(&ar->txqs_lock);
INIT_LIST_HEAD(&ar->txqs);
INIT_LIST_HEAD(&ar->peers);
init_waitqueue_head(&ar->peer_mapping_wq);
init_waitqueue_head(&ar->htt.empty_tx_wq);
init_waitqueue_head(&ar->wmi.tx_credits_wq);
init_completion(&ar->offchan_tx_completed);
INIT_WORK(&ar->offchan_tx_work, ath10k_offchan_tx_work);
skb_queue_head_init(&ar->offchan_tx_queue);
INIT_WORK(&ar->wmi_mgmt_tx_work, ath10k_mgmt_over_wmi_tx_work);
skb_queue_head_init(&ar->wmi_mgmt_tx_queue);
INIT_WORK(&ar->register_work, ath10k_core_register_work);
INIT_WORK(&ar->restart_work, ath10k_core_restart);
ret = ath10k_debug_create(ar);
if (ret)
goto err_free_aux_wq;
return ar;
err_free_aux_wq:
destroy_workqueue(ar->workqueue_aux);
err_free_wq:
destroy_workqueue(ar->workqueue);
err_free_mac:
ath10k_mac_destroy(ar);
return NULL;
} |
static void ath10k_send_suspend_complete(struct ath10k *ar);
static int ath10k_init_configure_target(struct ath10k *ar);
static int ath10k_download_cal_dt(struct ath10k *ar, const char *dt_name);
static int ath10k_download_cal_eeprom(struct ath10k *ar);
static int ath10k_core_get_board_id_from_otp(struct ath10k *ar);
static int ath10k_download_and_run_otp(struct ath10k *ar);
static int ath10k_download_fw(struct ath10k *ar);
static void ath10k_core_free_board_files(struct ath10k *ar);
static void ath10k_core_free_firmware_files(struct ath10k *ar);
static int ath10k_fetch_cal_file(struct ath10k *ar);
static int ath10k_core_fetch_board_data_api_1(struct ath10k *ar);
static int ath10k_core_fetch_board_file(struct ath10k *ar);
static int ath10k_core_fetch_firmware_files(struct ath10k *ar);
static int ath10k_core_pre_cal_download(struct ath10k *ar);
static int ath10k_core_pre_cal_config(struct ath10k *ar);
static int ath10k_download_cal_data(struct ath10k *ar);
static int ath10k_init_uart(struct ath10k *ar);
static int ath10k_init_hw_params(struct ath10k *ar);
static void ath10k_core_restart(struct work_struct *work);
static int ath10k_core_init_firmware_features(struct ath10k *ar);
int ath10k_wait_for_suspend(struct ath10k *ar, u32 suspend_opt);
void ath10k_core_stop(struct ath10k *ar);
static int ath10k_core_probe_fw(struct ath10k *ar);
static void ath10k_core_register_work(struct work_struct *work);
int ath10k_core_register(struct ath10k *ar, u32 chip_id);
void ath10k_core_unregister(struct ath10k *ar);
void ath10k_core_destroy(struct ath10k *ar);
| 0fc3a090f0dfb6a3ffa8482b91aa5be9bb83c13fb4c360dce19b62fc40e1b30e | 2,573 |
|
0x00evil | linux | drivers/scsi/am53c974.c | pci_esp_send_dma_cmd |
static void pci_esp_send_dma_cmd(struct esp *esp, u32 addr, u32 esp_count,
u32 dma_count, int write, u8 cmd)
{
struct pci_esp_priv *pep = pci_esp_get_priv(esp);
u32 val = 0;
BUG_ON(!(cmd & ESP_CMD_DMA));
pep->dma_status = 0;
if (write)
val |= ESP_DMA_CMD_DIR;
pci_esp_write8(esp, ESP_DMA_CMD_IDLE | val, ESP_DMA_CMD);
pci_esp_write8(esp, (esp_count >> 0) & 0xff, ESP_TCLOW);
pci_esp_write8(esp, (esp_count >> 8) & 0xff, ESP_TCMED);
if (esp->config2 & ESP_CONFIG2_FENAB)
pci_esp_write8(esp, (esp_count >> 16) & 0xff, ESP_TCHI);
pci_esp_write32(esp, esp_count, ESP_DMA_STC);
pci_esp_write32(esp, addr, ESP_DMA_SPA);
esp_dma_log("start dma addr[%x] count[%d:%d]\n",
addr, esp_count, dma_count);
scsi_esp_cmd(esp, cmd);
pci_esp_write8(esp, ESP_DMA_CMD_START | val, ESP_DMA_CMD);
} |
static inline struct pci_esp_priv *pci_esp_get_priv(struct esp *esp);
static void pci_esp_write8(struct esp *esp, u8 val, unsigned long reg);
static u8 pci_esp_read8(struct esp *esp, unsigned long reg);
static void pci_esp_write32(struct esp *esp, u32 val, unsigned long reg);
static int pci_esp_irq_pending(struct esp *esp);
static void pci_esp_reset_dma(struct esp *esp);
static void pci_esp_dma_drain(struct esp *esp);
static void pci_esp_dma_invalidate(struct esp *esp);
static int pci_esp_dma_error(struct esp *esp);
static u32 pci_esp_dma_length_limit(struct esp *esp, u32 dma_addr, u32 dma_len);
static void dc390_eeprom_prepare_read(struct pci_dev *pdev, u8 cmd);
static u16 dc390_eeprom_get_data(struct pci_dev *pdev);
static void dc390_read_eeprom(struct pci_dev *pdev, u16 *ptr);
static void dc390_check_eeprom(struct esp *esp);
static void pci_esp_remove_one(struct pci_dev *pdev);
static int __init am53c974_module_init(void);
static void __exit am53c974_module_exit(void);
| ebd893229aa4df9dc0f724715654fffe77f6a144a385764ea3e7464fc09e59e7 | 823 |
|
brikr | TerrainGeneration | src/terraingen.c | randint |
int randint(int min, int max) {
return min + rand() / (RAND_MAX / (max - min + 1) + 1);
} |
int main(int argc, char **argv);
void smooth(int width, int height, tile map[width][height], int waterlevel, int numpasses);
void genbeaches(int width, int height, tile map[width][height], int waterlevel);
void maptofile(int width, int height, tile map[width][height], int waterlevel, char *filename);
rgb_pixel_t getcolor(tile t, int waterlevel);
void badinput_exit(char *name);
void printhelp(char *name);
| b98c71b9293af20e66d9d15b36e111369c2b01a513886af8f65223fff2f2803f | 94 |
|
tacolin | C_libtaco | source/tmfd.c | tmfd_system_uninit |
void tmfd_system_uninit(void)
{
_is_running = 0;
pthread_join(_tick_thread, NULL);
LOCK();
list_clean(&_running_list);
list_clean(&_stopped_list);
UNLOCK();
return;
} |
static int _get_time_of_day(struct timeval* timeval, void* arg);
static int _find_tmfd_rec(void* data, void* arg);
static void _clean_tmfd_rec(void* data);
static void _add_rec_to_running_list(struct tmfd_rec* rec);
static void* _tick_routine(void* arg);
int tmfd_system_init(void);
int tmfd_create(int clockid, int flags);
int tmfd_settime(int tmfd, int flags, const struct itmfdspec *new_value, struct itmfdspec *old_value);
int tmfd_gettime(int tmfd, struct itmfdspec *old_value);
void tmfd_close(int tmfd);
| 5ea7d91561a0d77dd2976e55d464415e27021792ed96cc3c6b5042727b5b49bf | 196 |
|
htrb | ngraph-gtk | src/oaxis.c | int
axisautoscalefile | tic int
axisautoscalefile(struct objlist *obj,N_VALUE *inst,char *fileobj,double *rmin,double *rmax)
{
struct objlist *fobj;
int fnum;
int *fdata;
struct narray iarray;
double min,max,min1,max1;
int i,id,set;
char buf[20], msgbuf[64], *group;
char *argv2[4];
struct narray *minmax;
arrayinit(&iarray,sizeof(int));
if (getobjilist(fileobj,&fobj,&iarray,FALSE,NULL)) return 1;
fnum=arraynum(&iarray);
fdata=arraydata(&iarray);
_getobj(obj,"id",inst,&id);
snprintf(buf, sizeof(buf), "axis:%d",id);
_getobj(obj,"group",inst,&group);
argv2[0]=(void *)buf;
argv2[1]=NULL;
min = max = 0;
set=FALSE;
for (i=0;i<fnum;i++) {
double frac;
frac = 1.0 * i / fnum;
snprintf(msgbuf, sizeof(msgbuf), "%s (%.1f%%)", (group) ? group : buf, frac * 100);
set_progress(1, msgbuf, frac);
minmax=NULL;
getobj(fobj,"bounding",fdata[i],1,argv2,&minmax);
if (arraynum(minmax)>=2) {
min1=arraynget_double(minmax,0);
max1=arraynget_double(minmax,1);
if (!set) {
min=min1;
max=max1;
set=TRUE;
} else {
if (min1<min) min=min1;
if (max1>max) max=max1;
}
}
}
arraydel(&iarray);
if (!set) return 1;
*rmin=min;
*rmax=max;
return 0;
}
st | tatic double
calc_numbering_value(const struct axis_config *aconf, double po);
tic int
get_step(struct axislocal *alocal, int step, int *begin);
tic int
numbering(struct objlist *obj, N_VALUE *inst, int GC, struct axis_config *aconf, struct narray *array);
tic int
draw_gauge(struct objlist *obj,N_VALUE *inst, int GC, struct axis_config *aconf);
tic int
get_axis_parameter(struct objlist *obj, N_VALUE *inst, struct axis_config *aconf);
tic MathEquation *
get_axis_math(struct objlist *obj, char *math);
tic int
alloc_axis_math(struct objlist *obj, N_VALUE *inst, struct axis_config *aconf);
tic int
free_axis_math(struct axis_config *aconf);
tic int
get_reference_parameter(struct objlist *obj, N_VALUE *inst, struct axis_config *aconf, int ids_num, int *ids);
tic int
draw_wave(struct objlist *obj, N_VALUE *inst, struct axis_config *aconf, int GC);
tic int
draw_arrow(struct objlist *obj, N_VALUE *inst, struct axis_config *aconf, int GC);
tic int
axisdraw(struct objlist *obj,N_VALUE *inst,N_VALUE *rval,int argc,char **argv);
tic int
axis_get_numbering(struct objlist *obj, N_VALUE *inst, N_VALUE *rval, int argc, char **argv);
tic int
axisclear(struct objlist *obj,N_VALUE *inst,N_VALUE *rval,int argc,char **argv);
tic int
axisadjust(struct objlist *obj,N_VALUE *inst,N_VALUE *rval,int argc,char **argv);
tic int
axisscale(struct objlist *obj,N_VALUE *inst,N_VALUE *rval,int argc,char **argv);
tic int
axiscoordinate(struct objlist *obj,N_VALUE *inst,N_VALUE *rval,int argc,char **argv);
tic int
axistight(struct objlist *obj,N_VALUE *inst,N_VALUE *rval, int argc,char **argv);
tic void
set_group(struct objlist *obj, int gnum, int id, char axis, char type);
tic void
set_group_pos(struct objlist *obj, int id, int x, int y, int len, int dir);
tic void
axis_default_set(struct objlist *obj, int id, int oid, char *field, char *conf);
tic void
axis_default_set_ref(struct objlist *obj, int id, int oid, char *conf);
tic void
axis_default_set_adj(struct objlist *obj, int id, int oid, char *conf);
tic int
axis_save_group(struct objlist *obj, int type, N_VALUE **inst_array, N_VALUE *rval);
tic int
axissave(struct objlist *obj,N_VALUE *inst,N_VALUE *rval,int argc,char **argv);
axis_get_group(struct objlist *obj, N_VALUE *inst, struct AxisGroupInfo *info);
tic int
axismanager(struct objlist *obj,N_VALUE *inst,N_VALUE *rval,int argc,char **argv);
tic int
anumnozeroput(struct objlist *obj, N_VALUE *inst, N_VALUE *rval, int argc, char **argv);
tic int
anumdirput(struct objlist *obj,N_VALUE *inst,N_VALUE *rval, int argc,char **argv);
tic int
num_put_math(struct objlist *obj,N_VALUE *inst,N_VALUE *rval,int argc,char **argv);
tic int
put_gauge_hsb(struct objlist *obj, N_VALUE *inst, N_VALUE *rval, int argc, char **argv);
tic int
put_num_hsb(struct objlist *obj, N_VALUE *inst, N_VALUE *rval, int argc, char **argv);
tic int
axissaveconfig(struct objlist *obj, N_VALUE *inst, N_VALUE *rval, int argc, char **argv);
d *
addaxis(void);
| 7acf8db204038eb60a19d1db239ca94e605e5a7872ce155828f290b516282613 | 1,256 |
|
thomaslee | nim | libnim/code.c |
nim_bool_t
nim_code_pushconst |
nim_bool_t
nim_code_pushconst (NimRef *self, NimRef *value)
{
int32_t arg;
if (!nim_code_grow (self)) {
return NIM_FALSE;
}
arg = nim_code_add_const (self, value);
if (arg < 0) {
return NIM_FALSE;
}
NIM_NEXT_INSTR(self) = NIM_MAKE_INSTR1(PUSHCONST, arg);
return NIM_TRUE;
} | b57932c613f5cb6b2a4340e875d2055b59a6fa94e38d3cab84c615431dff64c2 | 322 |
||
01org | corelibs-arduino101 | cores/arduino/WInterrupts.c | noInterrupts |
void noInterrupts(void)
{
if (!noInterrupts_executed) {
noInterrupts_executed = 1;
irq_flags = interrupt_lock();
}
} |
void attachInterrupt(uint32_t pin, void(*callback);
void detachInterrupt(uint32_t pin);
void interrupts(void);
| 29e3ce328e93fba3e2f61fc9fd7753cc765807fa0fd64384b58d0eae3c72469a | 141 |
|
XMelancholy | android_kernel_huawei_h60 | drivers/vendor/hisi/modem/ps/nas/gu/src/Mm/Src/MmGsmDifMsg.c | NAS_MML_GetSimPsRegStatus | mPsRegStatus;
VOS_UINT8 ucPsAttachAllow;
ucSimPsRegStatus = NAS_MML_GetSimPsRegStatus();
ucPsAttachAllow = NAS_MML_GetPsAttachAllowFlg();
if (MM_CONST_ | NUM_0 != ucNetworkOperationMode);
req.");
UEPS_PID_MM,
(sizeof(RRMM_EST_REQ_STRU);
| 9c2104f5dcbb7feb63f44cf6ab3c406bdd8b03e83c42233ecbae937fd90b5795 | 209 |
|
Passtechsoft | TPEAlpGen | blender/source/blender/blenlib/intern/math_vector_inline.c | dot_v2v2 |
MINLINE float dot_v2v2(const float a[2], const float b[2])
{
return a[0] * b[0] + a[1] * b[1];
} |
MINLINE void zero_v2(float r[2]);
MINLINE void zero_v3(float r[3]);
MINLINE void zero_v4(float r[4]);
MINLINE void copy_v2_v2(float r[2], const float a[2]);
MINLINE void copy_v3_v3(float r[3], const float a[3]);
MINLINE void copy_v4_v4(float r[4], const float a[4]);
MINLINE void copy_v2_fl(float r[2], float f);
MINLINE void copy_v3_fl(float r[3], float f);
MINLINE void copy_v4_fl(float r[4], float f);
MINLINE void copy_v2_v2_uchar(unsigned char r[2], const unsigned char a[2]);
MINLINE void copy_v3_v3_uchar(unsigned char r[3], const unsigned char a[3]);
MINLINE void copy_v4_v4_uchar(unsigned char r[4], const unsigned char a[4]);
MINLINE void copy_v2_v2_char(char r[2], const char a[2]);
MINLINE void copy_v3_v3_char(char r[3], const char a[3]);
MINLINE void copy_v4_v4_char(char r[4], const char a[4]);
MINLINE void zero_v3_int(int r[3]);
MINLINE void copy_v2_v2_short(short r[2], const short a[2]);
MINLINE void copy_v3_v3_short(short r[3], const short a[3]);
MINLINE void copy_v4_v4_short(short r[4], const short a[4]);
MINLINE void copy_v2_v2_int(int r[2], const int a[2]);
MINLINE void copy_v3_v3_int(int r[3], const int a[3]);
MINLINE void copy_v4_v4_int(int r[4], const int a[4]);
MINLINE void copy_v2fl_v2db(float r[2], const double a[2]);
MINLINE void copy_v3fl_v3db(float r[3], const double a[3]);
MINLINE void copy_v4fl_v4db(float r[4], const double a[4]);
MINLINE void copy_v2db_v2fl(double r[2], const float a[2]);
MINLINE void copy_v3db_v3fl(double r[3], const float a[3]);
MINLINE void copy_v4db_v4fl(double r[4], const float a[4]);
MINLINE void swap_v2_v2(float a[2], float b[2]);
MINLINE void swap_v3_v3(float a[3], float b[3]);
MINLINE void swap_v4_v4(float a[4], float b[4]);
MINLINE void copy_v2_fl2(float v[2], float x, float y);
MINLINE void copy_v3_fl3(float v[3], float x, float y, float z);
MINLINE void copy_v4_fl4(float v[4], float x, float y, float z, float w);
MINLINE void add_v2_fl(float r[2], float f);
MINLINE void add_v3_fl(float r[3], float f);
MINLINE void add_v4_fl(float r[4], float f);
MINLINE void add_v2_v2(float r[2], const float a[2]);
MINLINE void add_v2_v2v2(float r[2], const float a[2], const float b[2]);
MINLINE void add_v2_v2v2_int(int r[2], const int a[2], const int b[2]);
MINLINE void add_v3_v3(float r[3], const float a[3]);
MINLINE void add_v3_v3v3(float r[3], const float a[3], const float b[3]);
MINLINE void add_v4_v4(float r[4], const float a[4]);
MINLINE void add_v4_v4v4(float r[4], const float a[4], const float b[4]);
MINLINE void sub_v2_v2(float r[2], const float a[2]);
MINLINE void sub_v2_v2v2(float r[2], const float a[2], const float b[2]);
MINLINE void sub_v2_v2v2_int(int r[2], const int a[2], const int b[2]);
MINLINE void sub_v3_v3(float r[3], const float a[3]);
MINLINE void sub_v3_v3v3(float r[3], const float a[3], const float b[3]);
MINLINE void sub_v4_v4(float r[4], const float a[4]);
MINLINE void sub_v4_v4v4(float r[4], const float a[4], const float b[4]);
MINLINE void mul_v2_fl(float r[2], float f);
MINLINE void mul_v2_v2fl(float r[2], const float a[2], float f);
MINLINE void mul_v3_fl(float r[3], float f);
MINLINE void mul_v3_v3fl(float r[3], const float a[3], float f);
MINLINE void mul_v2_v2(float r[2], const float a[2]);
MINLINE void mul_v3_v3(float r[3], const float a[3]);
MINLINE void mul_v4_fl(float r[4], float f);
MINLINE void mul_v4_v4fl(float r[4], const float a[4], float f);
MINLINE void mul_v2_v2_cw(float r[2], const float mat[2], const float vec[2]);
MINLINE void mul_v2_v2_ccw(float r[2], const float mat[2], const float vec[2]);
MINLINE float mul_project_m4_v3_zfac(float mat[4][4], const float co[3]);
MINLINE float dot_m3_v3_row_x(float M[3][3], const float a[3]);
MINLINE float dot_m3_v3_row_y(float M[3][3], const float a[3]);
MINLINE float dot_m3_v3_row_z(float M[3][3], const float a[3]);
MINLINE float dot_m4_v3_row_x(float M[4][4], const float a[3]);
MINLINE float dot_m4_v3_row_y(float M[4][4], const float a[3]);
MINLINE float dot_m4_v3_row_z(float M[4][4], const float a[3]);
MINLINE void madd_v2_v2fl(float r[2], const float a[2], float f);
MINLINE void madd_v3_v3fl(float r[3], const float a[3], float f);
MINLINE void madd_v3_v3v3(float r[3], const float a[3], const float b[3]);
MINLINE void madd_v2_v2v2fl(float r[2], const float a[2], const float b[2], float f);
MINLINE void madd_v3_v3v3fl(float r[3], const float a[3], const float b[3], float f);
MINLINE void madd_v3_v3v3v3(float r[3], const float a[3], const float b[3], const float c[3]);
MINLINE void madd_v4_v4fl(float r[4], const float a[4], float f);
MINLINE void madd_v4_v4v4(float r[4], const float a[4], const float b[4]);
MINLINE void mul_v3_v3v3(float r[3], const float v1[3], const float v2[3]);
MINLINE void negate_v2(float r[2]);
MINLINE void negate_v2_v2(float r[2], const float a[2]);
MINLINE void negate_v3(float r[3]);
MINLINE void negate_v3_v3(float r[3], const float a[3]);
MINLINE void negate_v4(float r[4]);
MINLINE void negate_v4_v4(float r[4], const float a[4]);
MINLINE void negate_v3_short(short r[3]);
MINLINE void abs_v2(float r[2]);
MINLINE void abs_v2_v2(float r[2], const float a[2]);
MINLINE void abs_v3(float r[3]);
MINLINE void abs_v3_v3(float r[3], const float a[3]);
MINLINE void abs_v4(float r[4]);
MINLINE void abs_v4_v4(float r[4], const float a[4]);
MINLINE float dot_v3v3(const float a[3], const float b[3]);
MINLINE float dot_v3v3v3(const float p[3], const float a[3], const float b[3]);
MINLINE float dot_v4v4(const float a[4], const float b[4]);
MINLINE double dot_v3db_v3fl(const double a[3], const float b[3]);
MINLINE float cross_v2v2(const float a[2], const float b[2]);
MINLINE void cross_v3_v3v3(float r[3], const float a[3], const float b[3]);
MINLINE void add_newell_cross_v3_v3v3(float n[3], const float v_prev[3], const float v_curr[3]);
MINLINE void star_m3_v3(float rmat[3][3], float a[3]);
MINLINE float len_squared_v2(const float v[2]);
MINLINE float len_squared_v3(const float v[3]);
MINLINE float len_manhattan_v2(const float v[2]);
MINLINE int len_manhattan_v2_int(const int v[2]);
MINLINE float len_manhattan_v3(const float v[3]);
MINLINE float len_v2(const float v[2]);
MINLINE float len_v2v2(const float v1[2], const float v2[2]);
MINLINE float len_v2v2_int(const int v1[2], const int v2[2]);
MINLINE float len_v3(const float a[3]);
MINLINE float len_squared_v2v2(const float a[2], const float b[2]);
MINLINE float len_squared_v3v3(const float a[3], const float b[3]);
MINLINE float len_manhattan_v2v2(const float a[2], const float b[2]);
MINLINE int len_manhattan_v2v2_int(const int a[2], const int b[2]);
MINLINE float len_manhattan_v3v3(const float a[3], const float b[3]);
MINLINE float len_v3v3(const float a[3], const float b[3]);
MINLINE float normalize_v2_v2(float r[2], const float a[2]);
MINLINE float normalize_v2(float n[2]);
MINLINE float normalize_v3_v3(float r[3], const float a[3]);
MINLINE double normalize_v3_d(double n[3]);
MINLINE float normalize_v3(float n[3]);
MINLINE void normal_short_to_float_v3(float out[3], const short in[3]);
MINLINE void normal_float_to_short_v3(short out[3], const float in[3]);
MINLINE bool is_zero_v2(const float v[2]);
MINLINE bool is_zero_v3(const float v[3]);
MINLINE bool is_zero_v4(const float v[4]);
MINLINE bool is_finite_v2(const float v[2]);
MINLINE bool is_finite_v3(const float v[3]);
MINLINE bool is_finite_v4(const float v[4]);
MINLINE bool is_one_v3(const float v[3]);
MINLINE bool equals_v2v2(const float v1[2], const float v2[2]);
MINLINE bool equals_v3v3(const float v1[3], const float v2[3]);
MINLINE bool equals_v4v4(const float v1[4], const float v2[4]);
MINLINE bool compare_v2v2(const float v1[2], const float v2[2], const float limit);
MINLINE bool compare_v3v3(const float v1[3], const float v2[3], const float limit);
MINLINE bool compare_v4v4(const float v1[4], const float v2[4], const float limit);
MINLINE bool compare_v2v2_relative(const float v1[2], const float v2[2], const float limit, const int max_ulps);
MINLINE bool compare_v3v3_relative(const float v1[3], const float v2[3], const float limit, const int max_ulps);
MINLINE bool compare_v4v4_relative(const float v1[4], const float v2[4], const float limit, const int max_ulps);
MINLINE bool compare_len_v3v3(const float v1[3], const float v2[3], const float limit);
MINLINE bool compare_len_squared_v3v3(const float v1[3], const float v2[3], const float limit_sq);
MINLINE float line_point_side_v2(const float l1[2], const float l2[2], const float pt[2]);
| 9aaa5a9a5a15f46da35e7b796eee15b049b3eacc1d07375ef3d1181bafcc372e | 98 |
|
akaasjager | sslscan | sslscan.c | main | nt main(int argc, char *argv[])
{
struct sslCheckOptions options;
struct sslCipher *sslCipherPointer;
int argLoop;
int tempInt;
int maxSize;
int xmlArg;
int mode = mode_help;
int msec;
FILE *targetsFile;
char line[1024];
#ifdef _WIN32
WORD wVersionRequested;
WSADATA wsaData;
int err;
#endif
memset(&options, 0, sizeof(struct sslCheckOptions));
options.port = 0;
xmlArg = 0;
strcpy(options.host, "127.0.0.1");
options.noFailed = true;
options.showCertificate = false;
options.showTrustedCAs = false;
options.checkCertificate = true;
options.showClientCiphers = false;
options.ciphersuites = true;
options.reneg = true;
options.compression = true;
options.heartbleed = true;
options.starttls_ftp = false;
options.starttls_imap = false;
options.starttls_irc = false;
options.starttls_pop3 = false;
options.starttls_smtp = false;
options.starttls_xmpp = false;
options.xmpp_server = false;
options.verbose = false;
options.cipher_details = true;
options.ipv4 = true;
options.ipv6 = true;
options.getPreferredCiphers = true;
options.ocspStatus = false;
options.timeout.tv_sec = 3;
options.timeout.tv_usec = 0;
options.sleep = 0;
options.sslVersion = ssl_all;
#ifdef _WIN32
wVersionRequested = MAKEWORD(2, 2);
err = WSAStartup(wVersionRequested, &wsaData);
if (err != 0)
{
printf_error("WSAStartup failed: %d\n", err);
return -1;
}
#endif
SSL_library_init();
for (argLoop = 1; argLoop < argc; argLoop++)
{
if ((strcmp("--help", argv[argLoop]) == 0) || (strcmp("-h", argv[argLoop]) == 0))
mode = mode_help;
else if ((strncmp("--targets=", argv[argLoop], 10) == 0) && (strlen(argv[argLoop]) > 10))
{
mode = mode_multiple;
options.targets = argLoop;
}
else if (strcmp("--failed", argv[argLoop]) == 0)
options.noFailed = false;
else if (strcmp("--show-certificate", argv[argLoop]) == 0)
options.showCertificate = true;
else if (strcmp("--no-check-certificate", argv[argLoop]) == 0)
options.checkCertificate = false;
else if (strcmp("--show-ciphers", argv[argLoop]) == 0)
options.showClientCiphers = true;
else if (strcmp("--show-client-cas", argv[argLoop]) == 0)
options.showTrustedCAs = true;
else if (strcmp("--version", argv[argLoop]) == 0)
mode = mode_version;
else if (strncmp("--xml=", argv[argLoop], 6) == 0)
xmlArg = argLoop;
else if (strcmp("--verbose", argv[argLoop]) == 0)
options.verbose = true;
#if OPENSSL_VERSION_NUMBER >= 0x10002000L
else if (strcmp("--no-cipher-details", argv[argLoop]) == 0)
options.cipher_details = false;
#endif
else if ((strcmp("--no-colour", argv[argLoop]) == 0) || (strcmp("--no-color", argv[argLoop]) == 0))
{
RESET = "";
COL_RED = "";
COL_YELLOW = "";
COL_BLUE = "";
COL_GREEN = "";
COL_PURPLE = "";
COL_RED_BG = "";
}
else if (strncmp("--certs=", argv[argLoop], 8) == 0)
options.clientCertsFile = argv[argLoop] +8;
else if (strncmp("--pk=", argv[argLoop], 5) == 0)
options.privateKeyFile = argv[argLoop] +5;
else if (strncmp("--pkpass=", argv[argLoop], 9) == 0)
options.privateKeyPassword = argv[argLoop] +9;
else if (strcmp("--no-ciphersuites", argv[argLoop]) == 0)
options.ciphersuites = false;
else if (strcmp("--no-renegotiation", argv[argLoop]) == 0)
options.reneg = false;
else if (strcmp("--no-compression", argv[argLoop]) == 0)
options.compression = false;
else if (strcmp("--no-heartbleed", argv[argLoop]) == 0)
options.heartbleed = false;
else if (strcmp("--no-preferred", argv[argLoop]) == 0)
options.getPreferredCiphers = false;
else if (strcmp("--starttls-ftp", argv[argLoop]) == 0)
options.starttls_ftp = true;
else if (strcmp("--starttls-imap", argv[argLoop]) == 0)
options.starttls_imap = true;
else if (strcmp("--starttls-irc", argv[argLoop]) == 0)
options.starttls_irc = true;
else if (strcmp("--starttls-pop3", argv[argLoop]) == 0)
options.starttls_pop3 = true;
else if (strcmp("--starttls-smtp", argv[argLoop]) == 0)
options.starttls_smtp = true;
else if (strcmp("--starttls-xmpp", argv[argLoop]) == 0)
options.starttls_xmpp = true;
#ifndef OPENSSL_NO_SSL2
else if (strcmp("--ssl2", argv[argLoop]) == 0)
options.sslVersion = ssl_v2;
#endif
#ifndef OPENSSL_NO_SSL3
else if (strcmp("--ssl3", argv[argLoop]) == 0)
options.sslVersion = ssl_v3;
#endif
else if (strcmp("--tls10", argv[argLoop]) == 0)
options.sslVersion = tls_v10;
#if OPENSSL_VERSION_NUMBER >= 0x10001000L
else if (strcmp("--tls11", argv[argLoop]) == 0)
options.sslVersion = tls_v11;
else if (strcmp("--tls12", argv[argLoop]) == 0)
options.sslVersion = tls_v12;
#endif
else if (strcmp("--tlsall", argv[argLoop]) == 0)
options.sslVersion = tls_all;
else if (strcmp("--xmpp-server", argv[argLoop]) == 0)
options.xmpp_server = true;
else if (strcmp("--bugs", argv[argLoop]) == 0)
options.sslbugs = 1;
else if (strncmp("--timeout=", argv[argLoop], 10) == 0)
options.timeout.tv_sec = atoi(argv[argLoop] + 10);
else if (strncmp("--sleep=", argv[argLoop], 8) == 0)
{
msec = atoi(argv[argLoop] + 8);
if (msec >= 0) {
options.sleep = msec;
}
}
else if (strcmp("--http", argv[argLoop]) == 0)
options.http = 1;
else if (strcmp("--rdp", argv[argLoop]) == 0)
options.rdp = 1;
else if (strcmp("--ipv4", argv[argLoop]) == 0)
options.ipv6 = false;
else if (strcmp("--ipv6", argv[argLoop]) == 0)
options.ipv4 = false;
else if (strcmp("--ocsp", argv[argLoop]) == 0)
options.ocspStatus = true;
else if (argLoop + 1 == argc)
{
mode = mode_single;
tempInt = 0;
char *hostString = argv[argLoop];
maxSize = strlen(hostString);
if (strncmp((char*)hostString, "https:
{
memmove(hostString, hostString + 8, (maxSize - 8));
memset(hostString + (maxSize - 8), 0, 8);
maxSize = strlen(hostString);
}
int squareBrackets = false;
if (hostString[0] == '[')
{
squareBrackets = true;
hostString++;
}
while ((hostString[tempInt] != 0) && ((squareBrackets == true && hostString[tempInt] != ']') || (squareBrackets == false && hostString[tempInt] != ':')))
tempInt++;
if (squareBrackets == true && hostString[tempInt] == ']')
{
hostString[tempInt] = 0;
if (tempInt < maxSize && hostString[tempInt + 1] == ':')
{
tempInt++;
hostString[tempInt] = 0;
}
}
else
hostString[tempInt] = 0;
strncpy(options.host, hostString, sizeof(options.host) -1);
tempInt++;
if (tempInt < maxSize - 1)
options.port = atoi(hostString + tempInt);
else if (options.port == 0) {
if (options.starttls_ftp)
options.port = 21;
if (options.starttls_imap)
options.port = 143;
if (options.starttls_irc)
options.port = 6667;
if (options.starttls_pop3)
options.port = 110;
if (options.starttls_smtp)
options.port = 25;
if (options.starttls_xmpp)
options.port = 5222;
if (options.rdp)
options.port = 3389;
if (options.port == 0)
options.port = 443;
}
}
else
mode = mode_help;
}
|
int populateCipherList(struct sslCheckOptions *options, const SSL_METHOD *sslMethod);
int fileExists(char *fileName);
void readLine(FILE *input, char *lineFromFile, int maxSize);
int readOrLogAndClose(int fd, void* buffer, size_t len, const struct sslCheckOptions *options);
ssize_t sendString(int sockfd, const char str[]);
int tcpConnect(struct sslCheckOptions *options);
static int password_callback(char *buf, int size, int rwflag, void *userdata);
int loadCerts(struct sslCheckOptions *options);
int outputRenegotiation( struct sslCheckOptions *options, struct renegotiationOutput *outputData);
struct renegotiationOutput * newRenegotiationOutput( void );
int freeRenegotiationOutput( struct renegotiationOutput *myRenOut );
void tls_reneg_init(struct sslCheckOptions *options);
int testCompression(struct sslCheckOptions *options, const SSL_METHOD *sslMethod);
int testRenegotiation(struct sslCheckOptions *options, const SSL_METHOD *sslMethod);
onst char* printableSslMethod(const SSL_METHOD *sslMethod);
nt testHeartbleed(struct sslCheckOptions *options, const SSL_METHOD *sslMethod);
nt ssl_print_tmp_key(struct sslCheckOptions *options, SSL *s);
nt testCipher(struct sslCheckOptions *options, struct sslCipher *sslCipherPointer);
nt defaultCipher(struct sslCheckOptions *options, const SSL_METHOD *sslMethod);
nt checkCertificate(struct sslCheckOptions *options);
nt ocspRequest(struct sslCheckOptions *options);
tatic int ocsp_resp_cb(SSL *s, void *arg);
nt ocsp_certid_print(BIO *bp, OCSP_CERTID *a, int indent);
nt showCertificate(struct sslCheckOptions *options);
nt showTrustedCAs(struct sslCheckOptions *options);
nt testConnection(struct sslCheckOptions *options);
nt testHost(struct sslCheckOptions *options);
| 899e0a149c6fb8394c0ad9690519840d5b9d8583e18b09dbf8155d4c28b032ca | 9,141 |
|
lixiangbest | c | apue/06/05_time.c | main |
int main(){
char buf[MAXLINE];
time_t timet;
struct tm *p;
char *wday[] = {"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
struct timeval tv;
struct timezone tz;
gettimeofday(&tv, &tz);
printf("tv_sec: %d, tv_usec: %d\n", (int)tv.tv_sec, (int)tv.tv_usec);
printf("tz_minuteswest: %d, tz_dsttime: %d\n", tz.tz_minuteswest, tz.tz_dsttime);
time(&timet);
printf("time_t seconds:%d\n",(int)time((time_t*)NULL));
printf("time_t seconds:%d\n\n",(int)timet);
p = gmtime(&timet);
printf("time()->gmtime():tm_sec=%d,tm_min=%d,tm_hour=%d,tm_mday=%d,tm_mon=%d,tm_year=%d,tm_wday=%s,tm_yday=%d,tm_isdst=%d\n\n",p->tm_sec,p->tm_min,p->tm_hour,p->tm_mday,(1+p->tm_mon),(1900+p->tm_year),wday[p->tm_wday],p->tm_yday,p->tm_isdst);
p = localtime(&timet);
printf("time()->localtime():tm_sec=%d,tm_min=%d,tm_hour=%d,tm_mday=%d,tm_mon=%d,tm_year=%d,tm_wday=%s,tm_yday=%d,tm_isdst=%d\n\n",p->tm_sec,p->tm_min,p->tm_hour,p->tm_mday,(1+p->tm_mon),(1900+p->tm_year),wday[p->tm_wday],p->tm_yday,p->tm_isdst);
timet = mktime(p);
printf("time()->localtime()->mktime():%d\n\n",(int)timet);
printf("time()->gmtime()->asctime():%s\n", asctime(gmtime(&timet)));
printf("time()->localtime()->asctime():%s\n", asctime(localtime(&timet)));
printf("time()->ctime():%s\n", ctime(&timet));
printf("time()->gmtime()->strftime():\n");
printf("len:%d;", strftime(buf,MAXLINE,"%c,%Z,%G-%m-%d %H:%M:%S",gmtime(&timet)));
printf("%s\n",buf);
printf("\ntime()->localtime()->strftime():\n");
printf("len:%d;", strftime(buf,MAXLINE,"%c,%Z,%G-%m-%d %H:%M:%S",localtime(&timet)));
printf("%s\n",buf);
return 0;
} | 206ed24c7377aa7a3b971b1c0d307aebcdf758df28afefd7dd4bd7c42903af44 | 1,605 |
||
kidmaple | CoolWall | user/squid/src/client_side.c |
int
isTcpHit |
int
isTcpHit(log_type code)
{
if (code == LOG_TCP_HIT)
return 1;
if (code == LOG_TCP_IMS_HIT)
return 1;
if (code == LOG_TCP_REFRESH_FAIL_HIT)
return 1;
if (code == LOG_TCP_REFRESH_HIT)
return 1;
if (code == LOG_TCP_NEGATIVE_HIT)
return 1;
if (code == LOG_TCP_MEM_HIT)
return 1;
if (code == LOG_TCP_OFFLINE_HIT)
return 1;
return 0;
} | fead5194385b76409ad01def4670292129f69a8bd094d73efadbea22409d5cec | 378 |
||
gp-b2g | gp-keon-kernel | drivers/video/msm/mipi_ILI9487.c | mipi_ILI9487_device_register |
int mipi_ILI9487_device_register(struct msm_panel_info *pinfo,
u32 channel, u32 panel)
{
struct platform_device *pdev = NULL;
int ret;
printk("%s\n", __func__);
if ((channel >= 3) || ch_used[channel])
return -ENODEV;
ch_used[channel] = TRUE;
pdev = platform_device_alloc("mipi_ILI9487", (panel << 8)|channel);
if (!pdev)
return -ENOMEM;
ILI9487_panel_data.panel_info = *pinfo;
ret = platform_device_add_data(pdev, &ILI9487_panel_data, sizeof(ILI9487_panel_data));
if (ret) {
printk(KERN_ERR"%s: platform_device_add_data failed!\n", __func__);
goto err_device_put;
}
ret = platform_device_add(pdev);
if (ret) {
printk(KERN_ERR"%s: platform_device_register failed!\n", __func__);
goto err_device_put;
}
return 0;
err_device_put:
platform_device_put(pdev);
return ret;
} |
static void mipi_ILI9487_set_backlight(struct msm_fb_data_type *mfd);
static int mipi_ILI9487_lcd_on(struct platform_device *pdev);
static int mipi_ILI9487_lcd_off(struct platform_device *pdev);
static int __devinit mipi_ILI9487_lcd_probe(struct platform_device *pdev);
static int __init mipi_ILI9487_lcd_init(void);
| 14fbf119a6d5807d4d8e281fbcf6658b3e11cbe1e0d898b0cc74e4f04ce9e830 | 826 |
|
Ivnz | iFrameExtracotrWithFFMPEG | ffmpeg/libavfilter/libmpcodecs/vf_kerndeint.c | IsYUY2 |
static inline int IsYUY2(mp_image_t *mpi)
{
return mpi->imgfmt == IMGFMT_YUY2;
} |
static void uninit(struct vf_instance *vf);
static inline int IsRGB(mp_image_t *mpi);
static int put_image(struct vf_instance *vf, mp_image_t *mpi, double pts);
static int query_format(struct vf_instance *vf, unsigned int fmt);
static int control(struct vf_instance *vf, int request, void* data);
static int vf_open(vf_instance_t *vf, char *args);
| 71a50c9f416d865a22375fdf0af2ceb24b6b84b310914a2d497cc209ff447b32 | 85 |
|
johnl | collectd | src/thermal.c | thermal_submit | tic void thermal_submit (const char *plugin_instance, enum dev_type dt,
gauge_t value)
{
value_list_t vl = (dt == TEMP) ? vl_temp_template : vl_state_template;
value_t vt;
vt.gauge = value;
vl.values = &vt;
vl.time = time (NULL);
sstrncpy (vl.plugin, "thermal", sizeof(vl.plugin));
sstrncpy (vl.plugin_instance, plugin_instance,
sizeof(vl.plugin_instance));
sstrncpy (vl.type, (dt == TEMP) ? "temperature" : "gauge",
sizeof (vl.type));
plugin_dispatch_values (&vl);
}
st | tic int thermal_sysfs_device_read (const char *dir, const char *name,
void *user_data);
tic int thermal_procfs_device_read (const char *dir, const char *name,
void *user_data);
tic int thermal_config (const char *key, const char *value);
tic int thermal_sysfs_read (void);
tic int thermal_procfs_read (void);
tic int thermal_init (void);
tic int thermal_shutdown (void);
d module_register (void);
| 7bcb91aa8061fa0d291905906cc3e4321b4292fbc4bdc21e13474af5dd99cd90 | 491 |
|
blanham | qemu-NeXT | target-m68k/translate.c | DISAS_INSN | DISAS_INSN(fscc_mem)
{
int l1, l2;
TCGv taddr;
TCGv addr;
uint16_t ext;
ext = read_im16(env, s);
taddr = gen_lea(env, s, insn, OS_BYTE);
if (IS_NULL_QREG(taddr)) {
gen_addr_fault(s);
return;
}
addr = tcg_temp_local_new ();
tcg_gen_mov_i32(addr, taddr);
l1 = gen_new_label();
l2 = gen_new_label();
gen_fjmpcc(s, ext & 0x3f, l1);
gen_store(s, OS_BYTE, addr, tcg_const_i32(0x00));
tcg_gen_br(l2);
gen_set_label(l1);
gen_store(s, OS_BYTE, addr, tcg_const_i32(0xff));
gen_set_label(l2);
tcg_temp_free(addr);
}
|
void m68k_tcg_init(void);
static inline void qemu_assert(int cond, const char *msg);
static void set_cc_op(DisasContext *s, CCOp op);
static inline void update_cc_op(DisasContext *s);
static void gen_jmp_im(DisasContext *s, uint32_t dest);
static void gen_exception(DisasContext *s, uint32_t where, int nr);
static inline void gen_addr_fault(DisasContext *s);
static void gen_op_load_fpr_FP0(int freg);
static void gen_op_store_fpr_FP0(int freg);
static void gen_op_store_fpr_FP1(int freg);
static void gen_op_load_fpr_FP1(int freg);
static inline TCGv gen_load(DisasContext * s, int opsize, TCGv addr, int sign);
static inline void gen_store(DisasContext *s, int opsize, TCGv addr, TCGv val);
static inline uint32_t read_im8(CPUM68KState *env, DisasContext *s);
static inline uint32_t read_im16(CPUM68KState *env, DisasContext *s);
static inline uint32_t read_im32(CPUM68KState *env, DisasContext *s);
static inline uint64_t read_im64(CPUM68KState *env, DisasContext *s);
static TCGv gen_addr_index(uint16_t ext, TCGv tmp);
static inline void gen_flush_flags(DisasContext *s);
static void gen_logic_cc(DisasContext *s, TCGv val, int opsize);
static void gen_update_cc_add(TCGv dest, TCGv src);
static inline int opsize_bytes(int opsize);
static inline int insn_opsize(int insn, int pos);
static inline int ext_opsize(int ext, int pos);
static void gen_partset_reg(int opsize, TCGv reg, TCGv val);
static inline TCGv gen_extend(TCGv val, int opsize, int sign);
static inline void gen_extend_FP0(int opsize);
static inline void gen_reduce_FP0(int opsize);
static inline void gen_load_FP0(DisasContext * s, int opsize, TCGv addr);
static inline void gen_store_FP0(DisasContext *s, int opsize, TCGv addr);
static void gen_jmpcc(DisasContext *s, int cond, int l1);
DISAS_INSN(scc);
static void gen_lookup_tb(DisasContext *s);
static void gen_jmp(DisasContext *s, TCGv dest);
static void gen_jmp_tb(DisasContext *s, int n, uint32_t dest);
DISAS_INSN(scc_mem);
DISAS_INSN(dbcc);
DISAS_INSN(undef_mac);
DISAS_INSN(undef_fpu);
DISAS_INSN(undef);
DISAS_INSN(mulw);
DISAS_INSN(divw);
DISAS_INSN(divl);
DISAS_INSN(abcd_reg);
DISAS_INSN(abcd_mem);
DISAS_INSN(sbcd_reg);
DISAS_INSN(sbcd_mem);
DISAS_INSN(nbcd);
DISAS_INSN(addsub);
DISAS_INSN(bitrev);
DISAS_INSN(bitop_reg);
DISAS_INSN(sats);
static void gen_push(DisasContext *s, TCGv val);
DISAS_INSN(movem);
DISAS_INSN(bitop_im);
DISAS_INSN(arith_im);
DISAS_INSN(cas);
DISAS_INSN(byterev);
DISAS_INSN(move);
DISAS_INSN(negx);
DISAS_INSN(lea);
DISAS_INSN(clr);
static TCGv gen_get_ccr(DisasContext *s);
DISAS_INSN(move_from_ccr);
DISAS_INSN(neg);
static void gen_set_sr_im(DisasContext *s, uint16_t val, int ccr_only);
DISAS_INSN(move_to_ccr);
DISAS_INSN(not);
DISAS_INSN(swap);
DISAS_INSN(bkpt);
DISAS_INSN(pea);
DISAS_INSN(ext);
DISAS_INSN(tst);
DISAS_INSN(pulse);
DISAS_INSN(illegal);
DISAS_INSN(tas);
DISAS_INSN(mull);
DISAS_INSN(link);
DISAS_INSN(linkl);
DISAS_INSN(unlk);
DISAS_INSN(nop);
DISAS_INSN(rts);
DISAS_INSN(jump);
DISAS_INSN(addsubq);
DISAS_INSN(tpf);
DISAS_INSN(branch);
DISAS_INSN(moveq);
DISAS_INSN(mvzs);
DISAS_INSN(or);
DISAS_INSN(suba);
DISAS_INSN(subx_reg);
DISAS_INSN(subx_mem);
DISAS_INSN(mov3q);
DISAS_INSN(cmp);
DISAS_INSN(cmpa);
DISAS_INSN(eor);
DISAS_INSN(and);
DISAS_INSN(adda);
DISAS_INSN(addx_reg);
DISAS_INSN(addx_mem);
DISAS_INSN(shift8_im);
DISAS_INSN(shift16_im);
DISAS_INSN(shift_im);
DISAS_INSN(shift8_reg);
DISAS_INSN(shift16_reg);
DISAS_INSN(shift_reg);
DISAS_INSN(shift_mem);
DISAS_INSN(rotate_im);
DISAS_INSN(rotate8_im);
DISAS_INSN(rotate16_im);
DISAS_INSN(rotate_reg);
DISAS_INSN(rotate8_reg);
DISAS_INSN(rotate16_reg);
DISAS_INSN(rotate_mem);
static void bitfield_param(uint16_t ext, TCGv *offset, TCGv *width, TCGv *mask);
DISAS_INSN(bitfield_reg);
static TCGv_i64 gen_bitfield_mask(TCGv offset, TCGv width);
DISAS_INSN(bitfield_mem);
DISAS_INSN(ff1);
static TCGv gen_get_sr(DisasContext *s);
DISAS_INSN(strldsr);
DISAS_INSN(move_from_sr);
DISAS_INSN(move_to_sr);
DISAS_INSN(move_from_usp);
DISAS_INSN(move_to_usp);
DISAS_INSN(halt);
DISAS_INSN(stop);
DISAS_INSN(rte);
DISAS_INSN(movec);
DISAS_INSN(intouch);
DISAS_INSN(cpushl);
DISAS_INSN(wddata);
DISAS_INSN(wdebug);
DISAS_INSN(trap);
DISAS_INSN(fpu);
static void gen_fjmpcc(DisasContext *s, int cond, int l1);
DISAS_INSN(fbcc);
DISAS_INSN(fscc_reg);
DISAS_INSN(frestore);
DISAS_INSN(fsave);
static inline TCGv gen_mac_extract_word(DisasContext *s, TCGv val, int upper);
static void gen_mac_clear_flags(void);
DISAS_INSN(mac);
DISAS_INSN(from_mac);
DISAS_INSN(move_mac);
DISAS_INSN(from_macsr);
DISAS_INSN(from_mask);
DISAS_INSN(from_mext);
DISAS_INSN(macsr_to_ccr);
DISAS_INSN(to_mac);
DISAS_INSN(to_macsr);
DISAS_INSN(to_mask);
DISAS_INSN(to_mext);
DISAS_INSN(emulop_exec_return);
static void
register_opcode (disas_proc proc, uint16_t opcode, uint16_t mask);
void register_m68k_insns (CPUM68KState *env);
static void disas_m68k_insn(CPUM68KState * env, DisasContext *s);
void gen_intermediate_code(CPUM68KState *env, TranslationBlock *tb);
void gen_intermediate_code_pc(CPUM68KState *env, TranslationBlock *tb);
void m68k_cpu_dump_state(CPUState *cs, FILE *f, fprintf_function cpu_fprintf,
int flags);
void restore_state_to_opc(CPUM68KState *env, TranslationBlock *tb, int pc_pos);
| 0588d16100eb2e136307d6c1dae1727c663207a2296b12323675f12556ab3dd0 | 599 |
|
scanner-darkly | mod | skeleton/interrupts.c |
__attribute__ |
__attribute__((__interrupt__))
static void irq_port1_line1(void) {
if(gpio_get_pin_interrupt_flag(B09)) {
static event_t e;
e.type = kEventClockNormal;
e.data = !gpio_get_pin_value(B09);
if (!gpio_get_pin_value(B09)) {
last_external_ticks = 0;
external_clock_pulse_width = 10;
external_taps_index = external_taps_count = 0;
}
event_post(&e);
gpio_clear_pin_interrupt_flag(B09);
}
if(gpio_get_pin_interrupt_flag(B08)) {
print_dbg("\rclk: ");
print_dbg_ulong(gpio_get_pin_value(B08));
u64 elapsed = last_external_ticks < tcTicks ? tcTicks - last_external_ticks : tcMax - last_external_ticks + tcTicks;
if (gpio_get_pin_value(B08)) {
if (last_external_ticks != 0) {
if (elapsed < (u64)3600000) {
external_taps[external_taps_index] = elapsed;
if (++external_taps_index >= AVERAGING_TAPS) external_taps_index = 0;
if (external_taps_count < AVERAGING_TAPS) external_taps_count++;
}
}
last_external_ticks = tcTicks;
} else external_clock_pulse_width = elapsed;
(*clock_pulse)(gpio_get_pin_value(B08));
gpio_clear_pin_interrupt_flag(B08);
}
} |
__attribute__((__interrupt__);
__attribute__((__interrupt__);
void register_interrupts(void);
u32 get_external_clock_average(void);
| 4a733deb83ee48171b4e35a897e2991d195a9c6ef85c68e82cac797fa8c75c6b | 1,236 |
|
cseagle | unicorn | qemu/target/ppc/translate.c | gen_cnttzw |
static void gen_cnttzw(DisasContext *ctx)
{
TCGContext *tcg_ctx = ctx->uc->tcg_ctx;
TCGv_i32 t = tcg_temp_new_i32(tcg_ctx);
tcg_gen_trunc_tl_i32(tcg_ctx, t, cpu_gpr[rS(ctx->opcode)]);
tcg_gen_ctzi_i32(tcg_ctx, t, t, 32);
tcg_gen_extu_i32_tl(tcg_ctx, cpu_gpr[rA(ctx->opcode)], t);
tcg_temp_free_i32(tcg_ctx, t);
if (unlikely(Rc(ctx->opcode) != 0)) {
gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
}
} |
void ppc_translate_init(struct uc_struct *uc);
static inline bool need_byteswap(const DisasContext *ctx);
static inline void gen_load_spr(TCGContext *tcg_ctx, TCGv t, int reg);
static inline void gen_store_spr(TCGContext *tcg_ctx, int reg, TCGv t);
static inline void gen_set_access_type(DisasContext *ctx, int access_type);
static inline void gen_update_nip(DisasContext *ctx, target_ulong nip);
static void gen_exception_err(DisasContext *ctx, uint32_t excp, uint32_t error);
static void gen_exception(DisasContext *ctx, uint32_t excp);
static uint32_t gen_prep_dbgex(DisasContext *ctx);
static void gen_debug_exception(DisasContext *ctx);
static inline void gen_inval_exception(DisasContext *ctx, uint32_t error);
static inline void gen_priv_exception(DisasContext *ctx, uint32_t error);
static inline void gen_hvpriv_exception(DisasContext *ctx, uint32_t error);
static inline void gen_stop_exception(DisasContext *ctx);
static inline void gen_sync_exception(DisasContext *ctx);
static void gen_invalid(DisasContext *ctx);
static inline void gen_op_cmp(TCGContext *tcg_ctx, TCGv arg0, TCGv arg1, int s, int crf);
static inline void gen_op_cmpi(TCGContext *tcg_ctx, TCGv arg0, target_ulong arg1, int s, int crf);
static inline void gen_op_cmp32(TCGContext *tcg_ctx, TCGv arg0, TCGv arg1, int s, int crf);
static inline void gen_op_cmpi32(TCGContext *tcg_ctx, TCGv arg0, target_ulong arg1, int s, int crf);
static inline void gen_set_Rc0(DisasContext *ctx, TCGv reg);
static void gen_cmp(DisasContext *ctx);
static void gen_cmpi(DisasContext *ctx);
static void gen_cmpl(DisasContext *ctx);
static void gen_cmpli(DisasContext *ctx);
static void gen_cmprb(DisasContext *ctx);
static void gen_cmpeqb(DisasContext *ctx);
static void gen_isel(DisasContext *ctx);
static void gen_cmpb(DisasContext *ctx);
static void gen_addi(DisasContext *ctx);
static inline void gen_op_addic(DisasContext *ctx, bool compute_rc0);
static void gen_addic(DisasContext *ctx);
static void gen_addic_(DisasContext *ctx);
static void gen_addis(DisasContext *ctx);
static void gen_addpcis(DisasContext *ctx);
static void gen_mulhw(DisasContext *ctx);
static void gen_mulhwu(DisasContext *ctx);
static void gen_mullw(DisasContext *ctx);
static void gen_mullwo(DisasContext *ctx);
static void gen_mulli(DisasContext *ctx);
static void gen_mulhd(DisasContext *ctx);
static void gen_mulhdu(DisasContext *ctx);
static void gen_mulld(DisasContext *ctx);
static void gen_mulldo(DisasContext *ctx);
static void gen_subfic(DisasContext *ctx);
static inline void gen_op_arith_neg(DisasContext *ctx, bool compute_ov);
static void gen_neg(DisasContext *ctx);
static void gen_nego(DisasContext *ctx);
static void gen_andi_(DisasContext *ctx);
static void gen_andis_(DisasContext *ctx);
static void gen_cntlzw(DisasContext *ctx);
static void gen_pause(DisasContext *ctx);
static void gen_or(DisasContext *ctx);
| 8727513bdec43ede48bf79a6faebda965e5f54f3824c6ac5472fc50328899a99 | 439 |
|
cirnoworks | fiscevm | fiscevm-c-native/src/main/vmcore/BinarySaver.c | staticArea |
int classCount
{
int F15CE003
int classid
int handle
int clinited
int nameLength
char[] name
int staticSize
int[] staticArea
} | ;
;
;
;
static void writeInt(FILE *fp, fisce_uint value, fisce_exception *exception);
static void writeChar(FILE *fp, fisce_char value, fisce_exception *exception);
static void* saveBegin(struct fy_context *context, fisce_exception *exception);
static fisce_uint readInt(FILE *fp, fisce_exception *exception);
static fisce_char readChar(FILE *fp, fisce_exception *exception);
static void loadData(struct fy_context *context, fisce_exception *exception);
void fy_bsRegisterBinarySaver(fy_context *context);
| bc654373d990c3509a36dc28f3ff4c5d4b270edc75ba81d1c7dd84a2da791051 | 135 |
|
pelya | spearmint | code/botlib/be_ai_char.c | *BotLoadCharacterFromFile |
bot_character_t *BotLoadCharacterFromFile(char *charfile, int skill)
{
int indent, index, foundcharacter;
bot_character_t *ch;
source_t *source;
token_t token;
foundcharacter = qfalse;
PC_SetBaseFolder(BOTFILESBASEFOLDER);
source = LoadSourceFile(charfile);
if (!source)
{
botimport.Print(PRT_ERROR, "counldn't load %s\n", charfile);
return NULL;
}
ch = (bot_character_t *) GetClearedMemory(sizeof(bot_character_t) +
MAX_CHARACTERISTICS * sizeof(bot_characteristic_t));
strcpy(ch->filename, charfile);
while(PC_ReadToken(source, &token))
{
if (!strcmp(token.string, "skill"))
{
if (!PC_ExpectTokenType(source, TT_NUMBER, 0, &token))
{
FreeSource(source);
BotFreeCharacterStrings(ch);
FreeMemory(ch);
return NULL;
}
if (!PC_ExpectTokenString(source, "{"))
{
FreeSource(source);
BotFreeCharacterStrings(ch);
FreeMemory(ch);
return NULL;
}
if (skill < 0 || token.intvalue == skill)
{
foundcharacter = qtrue;
ch->skill = token.intvalue;
while(PC_ExpectAnyToken(source, &token))
{
if (!strcmp(token.string, "}")) break;
if (token.type != TT_NUMBER || !(token.subtype & TT_INTEGER))
{
SourceError(source, "expected integer index, found %s", token.string);
FreeSource(source);
BotFreeCharacterStrings(ch);
FreeMemory(ch);
return NULL;
}
index = token.intvalue;
if (index < 0 || index > MAX_CHARACTERISTICS)
{
SourceError(source, "characteristic index out of range [0, %d]", MAX_CHARACTERISTICS);
FreeSource(source);
BotFreeCharacterStrings(ch);
FreeMemory(ch);
return NULL;
}
if (ch->c[index].type)
{
SourceError(source, "characteristic %d already initialized", index);
FreeSource(source);
BotFreeCharacterStrings(ch);
FreeMemory(ch);
return NULL;
}
if (!PC_ExpectAnyToken(source, &token))
{
FreeSource(source);
BotFreeCharacterStrings(ch);
FreeMemory(ch);
return NULL;
}
if (token.type == TT_NUMBER)
{
if (token.subtype & TT_FLOAT)
{
ch->c[index].value._float = token.floatvalue;
ch->c[index].type = CT_FLOAT;
}
else
{
ch->c[index].value.integer = token.intvalue;
ch->c[index].type = CT_INTEGER;
}
}
else if (token.type == TT_STRING)
{
StripDoubleQuotes(token.string);
ch->c[index].value.string = GetMemory(strlen(token.string)+1);
strcpy(ch->c[index].value.string, token.string);
ch->c[index].type = CT_STRING;
}
else
{
SourceError(source, "expected integer, float or string, found %s", token.string);
FreeSource(source);
BotFreeCharacterStrings(ch);
FreeMemory(ch);
return NULL;
}
}
break;
}
else
{
indent = 1;
while(indent)
{
if (!PC_ExpectAnyToken(source, &token))
{
FreeSource(source);
BotFreeCharacterStrings(ch);
FreeMemory(ch);
return NULL;
}
if (!strcmp(token.string, "{")) indent++;
else if (!strcmp(token.string, "}")) indent--;
}
}
}
else
{
SourceError(source, "unknown definition %s", token.string);
FreeSource(source);
BotFreeCharacterStrings(ch);
FreeMemory(ch);
return NULL;
}
}
FreeSource(source);
if (!foundcharacter)
{
BotFreeCharacterStrings(ch);
FreeMemory(ch);
return NULL;
}
return ch;
} |
bot_character_t *BotCharacterFromHandle(int handle);
void BotDumpCharacter(bot_character_t *ch);
void BotFreeCharacterStrings(bot_character_t *ch);
void BotFreeCharacter2(int handle);
void BotFreeCharacter(int handle);
void BotDefaultCharacteristics(bot_character_t *ch, bot_character_t *defaultch);
int BotFindCachedCharacter(char *charfile, float skill);
int BotLoadCachedCharacter(char *charfile, float skill, int reload);
int BotLoadCharacterSkill(char *charfile, float skill);
int BotInterpolateCharacters(int handle1, int handle2, float desiredskill);
int BotLoadCharacter(char *charfile, float skill);
int CheckCharacteristicIndex(int character, int index);
float Characteristic_Float(int character, int index);
float Characteristic_BFloat(int character, int index, float min, float max);
int Characteristic_Integer(int character, int index);
int Characteristic_BInteger(int character, int index, int min, int max);
void Characteristic_String(int character, int index, char *buf, int size);
void BotShutdownCharacters(void);
| ade9487e2a71de16ee16f4246472c6181b8a5fd91b97795336bd94498420b513 | 3,525 |
|
AOKP | kernel_samsung_d2 | drivers/media/video/msm/mt9e013.c | mt9e013_get_pict_max_exp_lc |
static uint32_t mt9e013_get_pict_max_exp_lc(void)
{
if (mt9e013_ctrl->pict_res == QTR_SIZE)
return mt9e013_regs.reg_prev[E013_FRAME_LENGTH_LINES].wdata
* 24;
else if (mt9e013_ctrl->pict_res == FULL_SIZE)
return mt9e013_regs.reg_snap[E013_FRAME_LENGTH_LINES].wdata
* 24;
else if (mt9e013_ctrl->pict_res == HFR_60FPS)
return mt9e013_regs.reg_60fps[E013_FRAME_LENGTH_LINES].wdata
* 24;
else if (mt9e013_ctrl->pict_res == HFR_90FPS)
return mt9e013_regs.reg_120fps[E013_FRAME_LENGTH_LINES].wdata
* 24;
else
return mt9e013_regs.reg_120fps[E013_FRAME_LENGTH_LINES].wdata
* 24;
} |
static int32_t mt9e013_i2c_write_w_sensor(unsigned short waddr, uint16_t wdata);
static int32_t mt9e013_i2c_write_b_sensor(unsigned short waddr, uint8_t bdata);
static void mt9e013_group_hold_on(void);
static void mt9e013_group_hold_off(void);
static void mt9e013_start_stream(void);
static void mt9e013_stop_stream(void);
static void mt9e013_get_pict_fps(uint16_t fps, uint16_t *pfps);
static uint16_t mt9e013_get_prev_lines_pf(void);
static uint16_t mt9e013_get_prev_pixels_pl(void);
static uint16_t mt9e013_get_pict_lines_pf(void);
static uint16_t mt9e013_get_pict_pixels_pl(void);
static int32_t mt9e013_set_fps(struct fps_cfg *fps);
static int32_t mt9e013_write_exp_gain(uint16_t gain, uint32_t line);
static int32_t mt9e013_set_pict_exp_gain(uint16_t gain, uint32_t line);
static int32_t mt9e013_set_default_focus(uint8_t af_step);
static void mt9e013_init_focus(void);
static int32_t mt9e013_test(enum mt9e013_test_mode_t mo);
static int32_t mt9e013_sensor_setting(int update_type, int rt);
static int32_t mt9e013_video_config(int mode);
static int32_t mt9e013_snapshot_config(int mode);
static int32_t mt9e013_raw_snapshot_config(int mode);
static int32_t mt9e013_power_down(void);
static int mt9e013_probe_init_done(const struct msm_camera_sensor_info *data);
static int mt9e013_probe_init_sensor(const struct msm_camera_sensor_info *data);
int mt9e013_sensor_open_init(const struct msm_camera_sensor_info *data);
static int mt9e013_init_client(struct i2c_client *client);
static int mt9e013_send_wb_info(struct wb_info_cfg *wb);
static int __exit mt9e013_remove(struct i2c_client *client);
int mt9e013_sensor_config(void __user *argp);
static int mt9e013_sensor_release(void);
static int __mt9e013_probe(struct platform_device *pdev);
static int __init mt9e013_init(void);
void mt9e013_exit(void);
static int mt9e013_focus_test(void *data, u64 *val);
static int mt9e013_step_test(void *data, u64 *val);
static int cam_debug_stream_set(void *data, u64 val);
static int cam_debug_stream_get(void *data, u64 *val);
static int cam_debug_init(void);
| 823e119d4c28eb1d1486c968863d5b74b1e6681354f2c98719d82b9b9de3f26c | 602 |
|
oposs | dovecot-extensions | src/lib-storage/index/maildir/maildir-save.c | maildir_transaction_save_rollback |
void maildir_transaction_save_rollback(struct mail_save_context *_ctx)
{
struct maildir_save_context *ctx = (struct maildir_save_context *)_ctx;
i_assert(_ctx->data.output == NULL);
if (!ctx->last_save_finished)
maildir_save_cancel(&ctx->ctx);
maildir_save_unlink_files(ctx);
if (ctx->uidlist_sync_ctx != NULL)
(void)maildir_uidlist_sync_deinit(&ctx->uidlist_sync_ctx, FALSE);
if (ctx->sync_ctx != NULL)
maildir_sync_index_rollback(&ctx->sync_ctx);
if (ctx->locked)
maildir_uidlist_unlock(ctx->mbox->uidlist);
if (ctx->mail != NULL)
mail_free(&ctx->mail);
pool_unref(&ctx->pool);
} |
int maildir_save_begin(struct mail_save_context *_ctx, struct istream *input);
int maildir_save_continue(struct mail_save_context *_ctx);
static void maildir_save_remove_last_filename(struct maildir_save_context *ctx);
static int maildir_save_finish_real(struct mail_save_context *_ctx);
int maildir_save_finish(struct mail_save_context *ctx);
void maildir_save_cancel(struct mail_save_context *_ctx);
static int seq_range_cmp(const struct seq_range *r1, const struct seq_range *r2);
static void maildir_save_sync_uidlist(struct maildir_save_context *ctx);
int maildir_transaction_save_commit_pre(struct mail_save_context *_ctx);
| 2e21fa5af2e6a1b4264f6b6de5ea485af8337b2b2f60382c8ca97351d89d2530 | 609 |
|
UpgradeAndroid | telechips | arch/arm/mach-tcc892x/tcc_adc.c | tcc_adc_default_select |
static void tcc_adc_default_select(unsigned select)
{
} |
static inline void tcc_adc_convert(struct adc_device *adc);
static void tcc_adc_dbgshow(struct adc_device *adc);
void tcc_adc_try(struct adc_device *adc);
void tcc_adc_release(struct tcc_adc_client *client);
static int tcc_adc_probe(struct platform_device *pdev);
static int tcc_adc_remove(struct platform_device *pdev);
static int tcc_adc_suspend(struct platform_device *pdev, pm_message_t state);
static int tcc_adc_resume(struct platform_device *pdev);
static int __init adc_init(void);
| fbb3cfe38af5402f2dfa4c3616ece078c0fbbca0a531febc6e3d277944737563 | 58 |
|
786228836 | linux | ECE695-Spring17/t3-scheduler/linux-4.10.6/fs/udf/directory.c | *udf_fileident_read |
struct fileIdentDesc *udf_fileident_read(struct inode *dir, loff_t *nf_pos,
struct udf_fileident_bh *fibh,
struct fileIdentDesc *cfi,
struct extent_position *epos,
struct kernel_lb_addr *eloc, uint32_t *elen,
sector_t *offset)
{
struct fileIdentDesc *fi;
int i, num, block;
struct buffer_head *tmp, *bha[16];
struct udf_inode_info *iinfo = UDF_I(dir);
fibh->soffset = fibh->eoffset;
if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
fi = udf_get_fileident(iinfo->i_ext.i_data -
(iinfo->i_efe ?
sizeof(struct extendedFileEntry) :
sizeof(struct fileEntry)),
dir->i_sb->s_blocksize,
&(fibh->eoffset));
if (!fi)
return NULL;
*nf_pos += fibh->eoffset - fibh->soffset;
memcpy((uint8_t *)cfi, (uint8_t *)fi,
sizeof(struct fileIdentDesc));
return fi;
}
if (fibh->eoffset == dir->i_sb->s_blocksize) {
int lextoffset = epos->offset;
unsigned char blocksize_bits = dir->i_sb->s_blocksize_bits;
if (udf_next_aext(dir, epos, eloc, elen, 1) !=
(EXT_RECORDED_ALLOCATED >> 30))
return NULL;
block = udf_get_lb_pblock(dir->i_sb, eloc, *offset);
(*offset)++;
if ((*offset << blocksize_bits) >= *elen)
*offset = 0;
else
epos->offset = lextoffset;
brelse(fibh->sbh);
fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block);
if (!fibh->sbh)
return NULL;
fibh->soffset = fibh->eoffset = 0;
if (!(*offset & ((16 >> (blocksize_bits - 9)) - 1))) {
i = 16 >> (blocksize_bits - 9);
if (i + *offset > (*elen >> blocksize_bits))
i = (*elen >> blocksize_bits)-*offset;
for (num = 0; i > 0; i--) {
block = udf_get_lb_pblock(dir->i_sb, eloc,
*offset + i);
tmp = udf_tgetblk(dir->i_sb, block);
if (tmp && !buffer_uptodate(tmp) &&
!buffer_locked(tmp))
bha[num++] = tmp;
else
brelse(tmp);
}
if (num) {
ll_rw_block(REQ_OP_READ, REQ_RAHEAD, num, bha);
for (i = 0; i < num; i++)
brelse(bha[i]);
}
}
} else if (fibh->sbh != fibh->ebh) {
brelse(fibh->sbh);
fibh->sbh = fibh->ebh;
}
fi = udf_get_fileident(fibh->sbh->b_data, dir->i_sb->s_blocksize,
&(fibh->eoffset));
if (!fi)
return NULL;
*nf_pos += fibh->eoffset - fibh->soffset;
if (fibh->eoffset <= dir->i_sb->s_blocksize) {
memcpy((uint8_t *)cfi, (uint8_t *)fi,
sizeof(struct fileIdentDesc));
} else if (fibh->eoffset > dir->i_sb->s_blocksize) {
int lextoffset = epos->offset;
if (udf_next_aext(dir, epos, eloc, elen, 1) !=
(EXT_RECORDED_ALLOCATED >> 30))
return NULL;
block = udf_get_lb_pblock(dir->i_sb, eloc, *offset);
(*offset)++;
if ((*offset << dir->i_sb->s_blocksize_bits) >= *elen)
*offset = 0;
else
epos->offset = lextoffset;
fibh->soffset -= dir->i_sb->s_blocksize;
fibh->eoffset -= dir->i_sb->s_blocksize;
fibh->ebh = udf_tread(dir->i_sb, block);
if (!fibh->ebh)
return NULL;
if (sizeof(struct fileIdentDesc) > -fibh->soffset) {
int fi_len;
memcpy((uint8_t *)cfi, (uint8_t *)fi, -fibh->soffset);
memcpy((uint8_t *)cfi - fibh->soffset,
fibh->ebh->b_data,
sizeof(struct fileIdentDesc) + fibh->soffset);
fi_len = (sizeof(struct fileIdentDesc) +
cfi->lengthFileIdent +
le16_to_cpu(cfi->lengthOfImpUse) + 3) & ~3;
*nf_pos += fi_len - (fibh->eoffset - fibh->soffset);
fibh->eoffset = fibh->soffset + fi_len;
} else {
memcpy((uint8_t *)cfi, (uint8_t *)fi,
sizeof(struct fileIdentDesc));
}
}
return fi;
} |
struct fileIdentDesc *udf_get_fileident(void *buffer, int bufsize, int *offset);
struct long_ad *udf_get_filelongad(uint8_t *ptr, int maxoffset, uint32_t *offset, int inc);
| 42e5c9844f8a366a2dde3d05db0d7c00471e67dc59d789ae26d513f98b291a06 | 3,512 |
|
tamato | Boids | external/glad/glad.c | load_GL_ARB_fragment_program |
static void load_GL_ARB_fragment_program(GLADloadproc load) {
if(!GLAD_GL_ARB_fragment_program) return;
glad_glProgramStringARB = (PFNGLPROGRAMSTRINGARBPROC)load("glProgramStringARB");
glad_glBindProgramARB = (PFNGLBINDPROGRAMARBPROC)load("glBindProgramARB");
glad_glDeleteProgramsARB = (PFNGLDELETEPROGRAMSARBPROC)load("glDeleteProgramsARB");
glad_glGenProgramsARB = (PFNGLGENPROGRAMSARBPROC)load("glGenProgramsARB");
glad_glProgramEnvParameter4dARB = (PFNGLPROGRAMENVPARAMETER4DARBPROC)load("glProgramEnvParameter4dARB");
glad_glProgramEnvParameter4dvARB = (PFNGLPROGRAMENVPARAMETER4DVARBPROC)load("glProgramEnvParameter4dvARB");
glad_glProgramEnvParameter4fARB = (PFNGLPROGRAMENVPARAMETER4FARBPROC)load("glProgramEnvParameter4fARB");
glad_glProgramEnvParameter4fvARB = (PFNGLPROGRAMENVPARAMETER4FVARBPROC)load("glProgramEnvParameter4fvARB");
glad_glProgramLocalParameter4dARB = (PFNGLPROGRAMLOCALPARAMETER4DARBPROC)load("glProgramLocalParameter4dARB");
glad_glProgramLocalParameter4dvARB = (PFNGLPROGRAMLOCALPARAMETER4DVARBPROC)load("glProgramLocalParameter4dvARB");
glad_glProgramLocalParameter4fARB = (PFNGLPROGRAMLOCALPARAMETER4FARBPROC)load("glProgramLocalParameter4fARB");
glad_glProgramLocalParameter4fvARB = (PFNGLPROGRAMLOCALPARAMETER4FVARBPROC)load("glProgramLocalParameter4fvARB");
glad_glGetProgramEnvParameterdvARB = (PFNGLGETPROGRAMENVPARAMETERDVARBPROC)load("glGetProgramEnvParameterdvARB");
glad_glGetProgramEnvParameterfvARB = (PFNGLGETPROGRAMENVPARAMETERFVARBPROC)load("glGetProgramEnvParameterfvARB");
glad_glGetProgramLocalParameterdvARB = (PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC)load("glGetProgramLocalParameterdvARB");
glad_glGetProgramLocalParameterfvARB = (PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC)load("glGetProgramLocalParameterfvARB");
glad_glGetProgramivARB = (PFNGLGETPROGRAMIVARBPROC)load("glGetProgramivARB");
glad_glGetProgramStringARB = (PFNGLGETPROGRAMSTRINGARBPROC)load("glGetProgramStringARB");
glad_glIsProgramARB = (PFNGLISPROGRAMARBPROC)load("glIsProgramARB");
} |
int gladLoadGL(void);
static int get_exts(void);
static void free_exts(void);
static int has_ext(const char *ext);
static void load_GL_VERSION_1_0(GLADloadproc load);
static void load_GL_VERSION_1_1(GLADloadproc load);
static void load_GL_VERSION_1_2(GLADloadproc load);
static void load_GL_VERSION_1_3(GLADloadproc load);
static void load_GL_VERSION_1_4(GLADloadproc load);
static void load_GL_VERSION_1_5(GLADloadproc load);
static void load_GL_VERSION_2_0(GLADloadproc load);
static void load_GL_VERSION_2_1(GLADloadproc load);
static void load_GL_VERSION_3_0(GLADloadproc load);
static void load_GL_VERSION_3_1(GLADloadproc load);
static void load_GL_VERSION_3_2(GLADloadproc load);
static void load_GL_VERSION_3_3(GLADloadproc load);
static void load_GL_VERSION_4_0(GLADloadproc load);
static void load_GL_VERSION_4_1(GLADloadproc load);
static void load_GL_VERSION_4_2(GLADloadproc load);
static void load_GL_VERSION_4_3(GLADloadproc load);
static void load_GL_3DFX_tbuffer(GLADloadproc load);
static void load_GL_AMD_debug_output(GLADloadproc load);
static void load_GL_AMD_draw_buffers_blend(GLADloadproc load);
static void load_GL_AMD_gpu_shader_int64(GLADloadproc load);
static void load_GL_AMD_interleaved_elements(GLADloadproc load);
static void load_GL_AMD_multi_draw_indirect(GLADloadproc load);
static void load_GL_AMD_name_gen_delete(GLADloadproc load);
static void load_GL_AMD_occlusion_query_event(GLADloadproc load);
static void load_GL_AMD_performance_monitor(GLADloadproc load);
static void load_GL_AMD_sample_positions(GLADloadproc load);
static void load_GL_AMD_sparse_texture(GLADloadproc load);
static void load_GL_AMD_stencil_operation_extended(GLADloadproc load);
static void load_GL_AMD_vertex_shader_tessellator(GLADloadproc load);
static void load_GL_APPLE_element_array(GLADloadproc load);
static void load_GL_APPLE_fence(GLADloadproc load);
static void load_GL_APPLE_flush_buffer_range(GLADloadproc load);
static void load_GL_APPLE_object_purgeable(GLADloadproc load);
static void load_GL_APPLE_texture_range(GLADloadproc load);
static void load_GL_APPLE_vertex_array_object(GLADloadproc load);
static void load_GL_APPLE_vertex_array_range(GLADloadproc load);
static void load_GL_APPLE_vertex_program_evaluators(GLADloadproc load);
static void load_GL_ARB_ES2_compatibility(GLADloadproc load);
static void load_GL_ARB_ES3_1_compatibility(GLADloadproc load);
static void load_GL_ARB_ES3_2_compatibility(GLADloadproc load);
static void load_GL_ARB_base_instance(GLADloadproc load);
static void load_GL_ARB_bindless_texture(GLADloadproc load);
static void load_GL_ARB_blend_func_extended(GLADloadproc load);
static void load_GL_ARB_buffer_storage(GLADloadproc load);
static void load_GL_ARB_cl_event(GLADloadproc load);
static void load_GL_ARB_clear_buffer_object(GLADloadproc load);
static void load_GL_ARB_clear_texture(GLADloadproc load);
static void load_GL_ARB_clip_control(GLADloadproc load);
static void load_GL_ARB_color_buffer_float(GLADloadproc load);
static void load_GL_ARB_compute_shader(GLADloadproc load);
static void load_GL_ARB_compute_variable_group_size(GLADloadproc load);
static void load_GL_ARB_copy_buffer(GLADloadproc load);
static void load_GL_ARB_copy_image(GLADloadproc load);
static void load_GL_ARB_debug_output(GLADloadproc load);
static void load_GL_ARB_direct_state_access(GLADloadproc load);
static void load_GL_ARB_draw_buffers(GLADloadproc load);
static void load_GL_ARB_draw_buffers_blend(GLADloadproc load);
static void load_GL_ARB_draw_elements_base_vertex(GLADloadproc load);
static void load_GL_ARB_draw_indirect(GLADloadproc load);
static void load_GL_ARB_draw_instanced(GLADloadproc load);
static void load_GL_ARB_framebuffer_no_attachments(GLADloadproc load);
static void load_GL_ARB_framebuffer_object(GLADloadproc load);
static void load_GL_ARB_geometry_shader4(GLADloadproc load);
static void load_GL_ARB_get_program_binary(GLADloadproc load);
static void load_GL_ARB_get_texture_sub_image(GLADloadproc load);
static void load_GL_ARB_gpu_shader_fp64(GLADloadproc load);
static void load_GL_ARB_gpu_shader_int64(GLADloadproc load);
static void load_GL_ARB_imaging(GLADloadproc load);
static void load_GL_ARB_indirect_parameters(GLADloadproc load);
static void load_GL_ARB_instanced_arrays(GLADloadproc load);
static void load_GL_ARB_internalformat_query(GLADloadproc load);
static void load_GL_ARB_internalformat_query2(GLADloadproc load);
static void load_GL_ARB_invalidate_subdata(GLADloadproc load);
static void load_GL_ARB_map_buffer_range(GLADloadproc load);
static void load_GL_ARB_matrix_palette(GLADloadproc load);
static void load_GL_ARB_multi_bind(GLADloadproc load);
static void load_GL_ARB_multi_draw_indirect(GLADloadproc load);
static void load_GL_ARB_multisample(GLADloadproc load);
static void load_GL_ARB_multitexture(GLADloadproc load);
static void load_GL_ARB_occlusion_query(GLADloadproc load);
static void load_GL_ARB_parallel_shader_compile(GLADloadproc load);
static void load_GL_ARB_point_parameters(GLADloadproc load);
static void load_GL_ARB_program_interface_query(GLADloadproc load);
static void load_GL_ARB_provoking_vertex(GLADloadproc load);
static void load_GL_ARB_robustness(GLADloadproc load);
static void load_GL_ARB_sample_locations(GLADloadproc load);
static void load_GL_ARB_sample_shading(GLADloadproc load);
static void load_GL_ARB_sampler_objects(GLADloadproc load);
static void load_GL_ARB_separate_shader_objects(GLADloadproc load);
static void load_GL_ARB_shader_atomic_counters(GLADloadproc load);
static void load_GL_ARB_shader_image_load_store(GLADloadproc load);
static void load_GL_ARB_shader_objects(GLADloadproc load);
static void load_GL_ARB_shader_storage_buffer_object(GLADloadproc load);
static void load_GL_ARB_shader_subroutine(GLADloadproc load);
static void load_GL_ARB_shading_language_include(GLADloadproc load);
static void load_GL_ARB_sparse_buffer(GLADloadproc load);
static void load_GL_ARB_sparse_texture(GLADloadproc load);
static void load_GL_ARB_sync(GLADloadproc load);
static void load_GL_ARB_tessellation_shader(GLADloadproc load);
static void load_GL_ARB_texture_barrier(GLADloadproc load);
static void load_GL_ARB_texture_buffer_object(GLADloadproc load);
static void load_GL_ARB_texture_buffer_range(GLADloadproc load);
static void load_GL_ARB_texture_compression(GLADloadproc load);
static void load_GL_ARB_texture_multisample(GLADloadproc load);
static void load_GL_ARB_texture_storage(GLADloadproc load);
static void load_GL_ARB_texture_storage_multisample(GLADloadproc load);
static void load_GL_ARB_texture_view(GLADloadproc load);
static void load_GL_ARB_timer_query(GLADloadproc load);
static void load_GL_ARB_transform_feedback2(GLADloadproc load);
static void load_GL_ARB_transform_feedback3(GLADloadproc load);
static void load_GL_ARB_transform_feedback_instanced(GLADloadproc load);
static void load_GL_ARB_transpose_matrix(GLADloadproc load);
static void load_GL_ARB_uniform_buffer_object(GLADloadproc load);
static void load_GL_ARB_vertex_array_object(GLADloadproc load);
static void load_GL_ARB_vertex_attrib_64bit(GLADloadproc load);
static void load_GL_ARB_vertex_attrib_binding(GLADloadproc load);
static void load_GL_ARB_vertex_blend(GLADloadproc load);
static void load_GL_ARB_vertex_buffer_object(GLADloadproc load);
static void load_GL_ARB_vertex_program(GLADloadproc load);
static void load_GL_ARB_vertex_shader(GLADloadproc load);
static void load_GL_ARB_vertex_type_2_10_10_10_rev(GLADloadproc load);
static void load_GL_ARB_viewport_array(GLADloadproc load);
static void load_GL_ARB_window_pos(GLADloadproc load);
static void load_GL_ATI_draw_buffers(GLADloadproc load);
static void load_GL_ATI_element_array(GLADloadproc load);
static void load_GL_ATI_envmap_bumpmap(GLADloadproc load);
static void load_GL_ATI_fragment_shader(GLADloadproc load);
static void load_GL_ATI_map_object_buffer(GLADloadproc load);
static void load_GL_ATI_pn_triangles(GLADloadproc load);
static void load_GL_ATI_separate_stencil(GLADloadproc load);
static void load_GL_ATI_vertex_array_object(GLADloadproc load);
static void load_GL_ATI_vertex_attrib_array_object(GLADloadproc load);
static void load_GL_ATI_vertex_streams(GLADloadproc load);
static void load_GL_EXT_bindable_uniform(GLADloadproc load);
static void load_GL_EXT_blend_color(GLADloadproc load);
static void load_GL_EXT_blend_equation_separate(GLADloadproc load);
static void load_GL_EXT_blend_func_separate(GLADloadproc load);
static void load_GL_EXT_blend_minmax(GLADloadproc load);
static void load_GL_EXT_color_subtable(GLADloadproc load);
static void load_GL_EXT_compiled_vertex_array(GLADloadproc load);
static void load_GL_EXT_convolution(GLADloadproc load);
static void load_GL_EXT_coordinate_frame(GLADloadproc load);
static void load_GL_EXT_copy_texture(GLADloadproc load);
static void load_GL_EXT_cull_vertex(GLADloadproc load);
static void load_GL_EXT_debug_label(GLADloadproc load);
static void load_GL_EXT_debug_marker(GLADloadproc load);
static void load_GL_EXT_depth_bounds_test(GLADloadproc load);
static void load_GL_EXT_direct_state_access(GLADloadproc load);
static void load_GL_EXT_draw_buffers2(GLADloadproc load);
static void load_GL_EXT_draw_instanced(GLADloadproc load);
static void load_GL_EXT_draw_range_elements(GLADloadproc load);
static void load_GL_EXT_fog_coord(GLADloadproc load);
static void load_GL_EXT_framebuffer_blit(GLADloadproc load);
static void load_GL_EXT_framebuffer_multisample(GLADloadproc load);
static void load_GL_EXT_framebuffer_object(GLADloadproc load);
static void load_GL_EXT_geometry_shader4(GLADloadproc load);
static void load_GL_EXT_gpu_program_parameters(GLADloadproc load);
static void load_GL_EXT_gpu_shader4(GLADloadproc load);
static void load_GL_EXT_histogram(GLADloadproc load);
static void load_GL_EXT_index_func(GLADloadproc load);
static void load_GL_EXT_index_material(GLADloadproc load);
static void load_GL_EXT_light_texture(GLADloadproc load);
static void load_GL_EXT_multi_draw_arrays(GLADloadproc load);
static void load_GL_EXT_multisample(GLADloadproc load);
static void load_GL_EXT_paletted_texture(GLADloadproc load);
static void load_GL_EXT_pixel_transform(GLADloadproc load);
static void load_GL_EXT_point_parameters(GLADloadproc load);
static void load_GL_EXT_polygon_offset(GLADloadproc load);
static void load_GL_EXT_polygon_offset_clamp(GLADloadproc load);
static void load_GL_EXT_provoking_vertex(GLADloadproc load);
static void load_GL_EXT_raster_multisample(GLADloadproc load);
static void load_GL_EXT_secondary_color(GLADloadproc load);
static void load_GL_EXT_separate_shader_objects(GLADloadproc load);
static void load_GL_EXT_shader_image_load_store(GLADloadproc load);
static void load_GL_EXT_stencil_clear_tag(GLADloadproc load);
static void load_GL_EXT_stencil_two_side(GLADloadproc load);
static void load_GL_EXT_subtexture(GLADloadproc load);
static void load_GL_EXT_texture3D(GLADloadproc load);
static void load_GL_EXT_texture_array(GLADloadproc load);
static void load_GL_EXT_texture_buffer_object(GLADloadproc load);
static void load_GL_EXT_texture_filter_minmax(GLADloadproc load);
static void load_GL_EXT_texture_integer(GLADloadproc load);
static void load_GL_EXT_texture_object(GLADloadproc load);
static void load_GL_EXT_texture_perturb_normal(GLADloadproc load);
static void load_GL_EXT_timer_query(GLADloadproc load);
static void load_GL_EXT_transform_feedback(GLADloadproc load);
static void load_GL_EXT_vertex_array(GLADloadproc load);
static void load_GL_EXT_vertex_attrib_64bit(GLADloadproc load);
static void load_GL_EXT_vertex_shader(GLADloadproc load);
static void load_GL_EXT_vertex_weighting(GLADloadproc load);
static void load_GL_EXT_x11_sync_object(GLADloadproc load);
static void load_GL_GREMEDY_frame_terminator(GLADloadproc load);
static void load_GL_GREMEDY_string_marker(GLADloadproc load);
static void load_GL_HP_image_transform(GLADloadproc load);
static void load_GL_IBM_multimode_draw_arrays(GLADloadproc load);
static void load_GL_IBM_static_data(GLADloadproc load);
static void load_GL_IBM_vertex_array_lists(GLADloadproc load);
static void load_GL_INGR_blend_func_separate(GLADloadproc load);
static void load_GL_INTEL_framebuffer_CMAA(GLADloadproc load);
static void load_GL_INTEL_map_texture(GLADloadproc load);
static void load_GL_INTEL_parallel_arrays(GLADloadproc load);
static void load_GL_INTEL_performance_query(GLADloadproc load);
static void load_GL_KHR_blend_equation_advanced(GLADloadproc load);
static void load_GL_KHR_debug(GLADloadproc load);
static void load_GL_KHR_robustness(GLADloadproc load);
static void load_GL_MESA_resize_buffers(GLADloadproc load);
static void load_GL_MESA_window_pos(GLADloadproc load);
static void load_GL_NVX_conditional_render(GLADloadproc load);
static void load_GL_NV_bindless_multi_draw_indirect(GLADloadproc load);
static void load_GL_NV_bindless_multi_draw_indirect_count(GLADloadproc load);
static void load_GL_NV_bindless_texture(GLADloadproc load);
static void load_GL_NV_blend_equation_advanced(GLADloadproc load);
static void load_GL_NV_command_list(GLADloadproc load);
static void load_GL_NV_conditional_render(GLADloadproc load);
static void load_GL_NV_conservative_raster(GLADloadproc load);
static void load_GL_NV_conservative_raster_dilate(GLADloadproc load);
static void load_GL_NV_copy_image(GLADloadproc load);
static void load_GL_NV_depth_buffer_float(GLADloadproc load);
static void load_GL_NV_draw_texture(GLADloadproc load);
static void load_GL_NV_evaluators(GLADloadproc load);
static void load_GL_NV_explicit_multisample(GLADloadproc load);
static void load_GL_NV_fence(GLADloadproc load);
static void load_GL_NV_fragment_coverage_to_color(GLADloadproc load);
static void load_GL_NV_fragment_program(GLADloadproc load);
static void load_GL_NV_framebuffer_mixed_samples(GLADloadproc load);
static void load_GL_NV_framebuffer_multisample_coverage(GLADloadproc load);
static void load_GL_NV_geometry_program4(GLADloadproc load);
static void load_GL_NV_gpu_program4(GLADloadproc load);
static void load_GL_NV_gpu_program5(GLADloadproc load);
static void load_GL_NV_gpu_shader5(GLADloadproc load);
static void load_GL_NV_half_float(GLADloadproc load);
static void load_GL_NV_internalformat_sample_query(GLADloadproc load);
static void load_GL_NV_occlusion_query(GLADloadproc load);
static void load_GL_NV_parameter_buffer_object(GLADloadproc load);
static void load_GL_NV_path_rendering(GLADloadproc load);
static void load_GL_NV_pixel_data_range(GLADloadproc load);
static void load_GL_NV_point_sprite(GLADloadproc load);
static void load_GL_NV_present_video(GLADloadproc load);
static void load_GL_NV_primitive_restart(GLADloadproc load);
static void load_GL_NV_register_combiners(GLADloadproc load);
static void load_GL_NV_register_combiners2(GLADloadproc load);
static void load_GL_NV_sample_locations(GLADloadproc load);
static void load_GL_NV_shader_buffer_load(GLADloadproc load);
static void load_GL_NV_texture_barrier(GLADloadproc load);
static void load_GL_NV_texture_multisample(GLADloadproc load);
static void load_GL_NV_transform_feedback(GLADloadproc load);
static void load_GL_NV_transform_feedback2(GLADloadproc load);
static void load_GL_NV_vdpau_interop(GLADloadproc load);
static void load_GL_NV_vertex_array_range(GLADloadproc load);
static void load_GL_NV_vertex_attrib_integer_64bit(GLADloadproc load);
static void load_GL_NV_vertex_buffer_unified_memory(GLADloadproc load);
static void load_GL_NV_vertex_program(GLADloadproc load);
static void load_GL_NV_vertex_program4(GLADloadproc load);
static void load_GL_NV_video_capture(GLADloadproc load);
static void load_GL_OES_byte_coordinates(GLADloadproc load);
static void load_GL_OES_fixed_point(GLADloadproc load);
static void load_GL_OES_query_matrix(GLADloadproc load);
static void load_GL_OES_single_precision(GLADloadproc load);
static void load_GL_OVR_multiview(GLADloadproc load);
static void load_GL_PGI_misc_hints(GLADloadproc load);
static void load_GL_SGIS_detail_texture(GLADloadproc load);
static void load_GL_SGIS_fog_function(GLADloadproc load);
static void load_GL_SGIS_multisample(GLADloadproc load);
static void load_GL_SGIS_pixel_texture(GLADloadproc load);
static void load_GL_SGIS_point_parameters(GLADloadproc load);
static void load_GL_SGIS_sharpen_texture(GLADloadproc load);
static void load_GL_SGIS_texture4D(GLADloadproc load);
static void load_GL_SGIS_texture_color_mask(GLADloadproc load);
static void load_GL_SGIS_texture_filter4(GLADloadproc load);
static void load_GL_SGIX_async(GLADloadproc load);
static void load_GL_SGIX_flush_raster(GLADloadproc load);
static void load_GL_SGIX_fragment_lighting(GLADloadproc load);
static void load_GL_SGIX_framezoom(GLADloadproc load);
static void load_GL_SGIX_igloo_interface(GLADloadproc load);
static void load_GL_SGIX_instruments(GLADloadproc load);
static void load_GL_SGIX_list_priority(GLADloadproc load);
static void load_GL_SGIX_pixel_texture(GLADloadproc load);
static void load_GL_SGIX_polynomial_ffd(GLADloadproc load);
static void load_GL_SGIX_reference_plane(GLADloadproc load);
static void load_GL_SGIX_sprite(GLADloadproc load);
static void load_GL_SGIX_tag_sample_buffer(GLADloadproc load);
static void load_GL_SGI_color_table(GLADloadproc load);
static void load_GL_SUNX_constant_data(GLADloadproc load);
static void load_GL_SUN_global_alpha(GLADloadproc load);
static void load_GL_SUN_mesh_array(GLADloadproc load);
static void load_GL_SUN_triangle_list(GLADloadproc load);
static void load_GL_SUN_vertex(GLADloadproc load);
static int find_extensionsGL(void);
static void find_coreGL(void);
int gladLoadGLLoader(GLADloadproc load);
| 6de0c7726c2d2c007e34714878c0623147fff3c5cf4624af8373cadc8987a4f8 | 2,022 |
|
MoSync | MoSync | libs/MAStd/mawvsprintf.c | *iaddr |
static wchar_t *iaddr(wchar_t *str, wchar_t *addr, int size, int type)
{
wchar_t tmp[24];
int i, n, len;
len = 0;
for (i = 0; i < 4; i++)
{
if (i != 0) tmp[len++] = '.';
n = addr[i];
if (n == 0)
tmp[len++] = digits[0];
else
{
if (n >= 100)
{
tmp[len++] = digits[n / 100];
n = n % 100;
tmp[len++] = digits[n / 10];
n = n % 10;
}
else if (n >= 10)
{
tmp[len++] = digits[n / 10];
n = n % 10;
}
tmp[len++] = digits[n];
}
}
if (!(type & LEFT)) while (len < size--) *str++ = ' ';
for (i = 0; i < len; ++i) *str++ = tmp[i];
while (len < size--) *str++ = ' ';
return str;
} |
static wchar_t *cvt(double arg, int ndigits, int *decpt, int *sign, wchar_t *buf, int eflag);
static wchar_t *ecvtbuf(double arg, int ndigits, int *decpt, int *sign, wchar_t *buf);
static wchar_t *fcvtbuf(double arg, int ndigits, int *decpt, int *sign, wchar_t *buf);
static int skip_atoi(const wchar_t **s);
static wchar_t *number(wchar_t *str, long num, int base, int size, int precision, int type);
static wchar_t *eaddr(wchar_t *str, wchar_t *addr, int size, int type);
static void cfltcvt(double value, wchar_t *buffer, wchar_t fmt, int precision);
static void forcdecpt(wchar_t *buffer);
static void cropzeros(wchar_t *buffer);
static wchar_t *flt(wchar_t *str, double num, int size, int precision, wchar_t fmt, int flags);
int wvsprintf(wchar_t *buf, const wchar_t *fmt, va_list args);
int wsprintf(wchar_t *buf, const wchar_t *fmt, ...);
int wlprintfln(const wchar_t* fmt, ...);
| 8bfc256c6184f350f6698abb06af9276aa59fb33e1581daabd88eca15f76aff6 | 711 |
|
kernevil | samba | source3/torture/cmd_vfs.c | cmd_open |
static NTSTATUS cmd_open(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
{
int flags;
mode_t mode;
const char *flagstr;
files_struct *fsp;
struct files_struct *fspcwd = NULL;
struct smb_filename *smb_fname = NULL;
NTSTATUS status;
int ret;
mode = 00400;
if (argc < 3 || argc > 5) {
printf("Usage: open <filename> <flags> <mode>\n");
printf(" flags: O = O_RDONLY\n");
printf(" R = O_RDWR\n");
printf(" W = O_WRONLY\n");
printf(" C = O_CREAT\n");
printf(" E = O_EXCL\n");
printf(" T = O_TRUNC\n");
printf(" A = O_APPEND\n");
printf(" N = O_NONBLOCK/O_NDELAY\n");
#ifdef O_SYNC
printf(" S = O_SYNC\n");
#endif
#ifdef O_NOFOLLOW
printf(" F = O_NOFOLLOW\n");
#endif
printf(" mode: see open.2\n");
printf(" mode is ignored if C flag not present\n");
printf(" mode defaults to 00400\n");
return NT_STATUS_OK;
}
flags = 0;
flagstr = argv[2];
while (*flagstr) {
switch (*flagstr) {
case 'O':
flags |= O_RDONLY;
break;
case 'R':
flags |= O_RDWR;
break;
case 'W':
flags |= O_WRONLY;
break;
case 'C':
flags |= O_CREAT;
break;
case 'E':
flags |= O_EXCL;
break;
case 'T':
flags |= O_TRUNC;
break;
case 'A':
flags |= O_APPEND;
break;
case 'N':
flags |= O_NONBLOCK;
break;
#ifdef O_SYNC
case 'S':
flags |= O_SYNC;
break;
#endif
#ifdef O_NOFOLLOW
case 'F':
flags |= O_NOFOLLOW;
break;
#endif
default:
printf("open: error=-1 (invalid flag!)\n");
return NT_STATUS_UNSUCCESSFUL;
}
flagstr++;
}
if ((flags & O_CREAT) && argc == 4) {
if (sscanf(argv[3], "%ho", (unsigned short *)&mode) == 0) {
printf("open: error=-1 (invalid mode!)\n");
return NT_STATUS_UNSUCCESSFUL;
}
}
fsp = talloc_zero(vfs, struct files_struct);
if (fsp == NULL) {
return NT_STATUS_NO_MEMORY;
}
fsp->fh = talloc_zero(fsp, struct fd_handle);
if (fsp->fh == NULL) {
TALLOC_FREE(fsp);
return NT_STATUS_NO_MEMORY;
}
fsp->conn = vfs->conn;
smb_fname = synthetic_smb_fname_split(NULL,
argv[1],
lp_posix_pathnames());
if (smb_fname == NULL) {
TALLOC_FREE(fsp);
return NT_STATUS_NO_MEMORY;
}
fsp->fsp_name = smb_fname;
status = vfs_at_fspcwd(fsp, vfs->conn, &fspcwd);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
fsp->fh->fd = SMB_VFS_OPENAT(vfs->conn,
fspcwd,
smb_fname,
fsp,
flags,
mode);
if (fsp->fh->fd == -1) {
printf("open: error=%d (%s)\n", errno, strerror(errno));
TALLOC_FREE(fsp);
TALLOC_FREE(smb_fname);
return NT_STATUS_UNSUCCESSFUL;
}
status = NT_STATUS_OK;
ret = SMB_VFS_FSTAT(fsp, &smb_fname->st);
if (ret == -1) {
DEBUG(0,("Error doing fstat on open file %s "
"(%s)\n",
smb_fname_str_dbg(smb_fname),
strerror(errno) ));
status = map_nt_error_from_unix(errno);
} else if (S_ISDIR(smb_fname->st.st_ex_mode)) {
errno = EISDIR;
status = NT_STATUS_FILE_IS_A_DIRECTORY;
}
if (!NT_STATUS_IS_OK(status)) {
SMB_VFS_CLOSE(fsp);
TALLOC_FREE(fsp);
TALLOC_FREE(smb_fname);
return status;
}
fsp->file_id = vfs_file_id_from_sbuf(vfs->conn, &smb_fname->st);
fsp->vuid = UID_FIELD_INVALID;
fsp->file_pid = 0;
fsp->fsp_flags.can_lock = true;
fsp->fsp_flags.can_read = true;
fsp->fsp_flags.can_write = CAN_WRITE(vfs->conn);
fsp->print_file = NULL;
fsp->fsp_flags.modified = false;
fsp->sent_oplock_break = NO_BREAK_SENT;
fsp->fsp_flags.is_directory = false;
vfs->files[fsp->fh->fd] = fsp;
printf("open: fd=%d\n", fsp->fh->fd);
return NT_STATUS_OK;
} |
static uint32_t ssf_flags(void);
static NTSTATUS cmd_load_module(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv);
static NTSTATUS cmd_populate(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv);
static NTSTATUS cmd_show_data(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv);
static NTSTATUS cmd_connect(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv);
static NTSTATUS cmd_disconnect(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv);
static NTSTATUS cmd_disk_free(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv);
static NTSTATUS cmd_opendir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv);
static NTSTATUS cmd_readdir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv);
static NTSTATUS cmd_mkdir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv);
static NTSTATUS cmd_closedir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv);
static NTSTATUS cmd_pathfunc(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv);
static NTSTATUS cmd_close(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv);
static NTSTATUS cmd_read(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv);
static NTSTATUS cmd_write(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv);
static NTSTATUS cmd_lseek(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv);
static NTSTATUS cmd_rename(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv);
static NTSTATUS cmd_fsync(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv);
static NTSTATUS cmd_stat(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv);
static NTSTATUS cmd_fstat(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv);
static NTSTATUS cmd_lstat(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv);
static NTSTATUS cmd_chmod(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv);
static NTSTATUS cmd_fchmod(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv);
static NTSTATUS cmd_fchown(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv);
static NTSTATUS cmd_getwd(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv);
static NTSTATUS cmd_utime(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv);
static NTSTATUS cmd_ftruncate(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv);
static NTSTATUS cmd_lock(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv);
static NTSTATUS cmd_symlink(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv);
static NTSTATUS cmd_readlink(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv);
static NTSTATUS cmd_link(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv);
static NTSTATUS cmd_mknod(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv);
static NTSTATUS cmd_realpath(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv);
static NTSTATUS cmd_set_nt_acl(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv);
| eefbc36161a94b554473aacf1fdcd62ebeb5d5750dcc238103e4bab5cc904414 | 3,654 |
|
lieff | lvg | scripting/picoc/heap.c | HeapFreeMem |
void HeapFreeMem(Picoc *pc, void *Mem)
{
#ifdef USE_MALLOC_HEAP
free(Mem);
#else
struct AllocNode *MemNode = (struct AllocNode *)((char *)Mem - MEM_ALIGN(sizeof(MemNode->Size)));
int Bucket = MemNode->Size >> 2;
#ifdef DEBUG_HEAP
printf("HeapFreeMem(0x%lx)\n", (unsigned long)Mem);
#endif
assert((unsigned long)Mem >= (unsigned long)&(pc->HeapMemory)[0] && (unsigned char *)Mem - &(pc->HeapMemory)[0] < HEAP_SIZE);
assert(MemNode->Size < HEAP_SIZE && MemNode->Size > 0);
if (Mem == NULL)
return;
if ((void *)MemNode == pc->HeapBottom)
{
#ifdef DEBUG_HEAP
printf("freeing %d from bottom of heap\n", MemNode->Size);
#endif
pc->HeapBottom = (void *)((char *)pc->HeapBottom + MemNode->Size);
#ifdef DEBUG_HEAP
ShowBigList(pc);
#endif
}
else if (Bucket < FREELIST_BUCKETS)
{
#ifdef DEBUG_HEAP
printf("freeing %d to bucket\n", MemNode->Size);
#endif
assert(pc->FreeListBucket[Bucket] == NULL || ((unsigned long)pc->FreeListBucket[Bucket] >= (unsigned long)&(pc->HeapMemory)[0] && (unsigned char *)FreeListBucket[Bucket] - &HeapMemory[0] < HEAP_SIZE));
*(struct AllocNode **)MemNode = pc->FreeListBucket[Bucket];
pc->FreeListBucket[Bucket] = (struct AllocNode *)MemNode;
}
else
{
#ifdef DEBUG_HEAP
printf("freeing %lx:%d to freelist\n", (unsigned long)Mem, MemNode->Size);
#endif
assert(pc->FreeListBig == NULL || ((unsigned long)pc->FreeListBig >= (unsigned long)&(pc->HeapMemory)[0] && (unsigned char *)pc->FreeListBig - &(pc->HeapMemory)[0] < HEAP_SIZE));
MemNode->NextFree = pc->FreeListBig;
FreeListBig = MemNode;
#ifdef DEBUG_HEAP
ShowBigList(pc);
#endif
}
#endif
} |
void ShowBigList(Picoc *pc);
void HeapInit(Picoc *pc, int StackOrHeapSize);
void HeapCleanup(Picoc *pc);
void *HeapAllocStack(Picoc *pc, int Size);
void HeapUnpopStack(Picoc *pc, int Size);
int HeapPopStack(Picoc *pc, void *Addr, int Size);
void HeapPushStackFrame(Picoc *pc);
int HeapPopStackFrame(Picoc *pc);
void *HeapAllocMem(Picoc *pc, int Size);
| dac598002cced7c5119cbd7333e98235efa2e446d1a66208fa52bfed9f23f951 | 1,765 |
|
paoloach | ZigbeeElectronics | PowerMeter/Components/stack/zcl/zcl_general.c | zclGeneral_CountAllScenes |
uint8 zclGeneral_CountAllScenes( void )
{
zclGenSceneItem_t *pLoop;
uint8 cnt = 0;
pLoop = zclGenSceneTable;
while ( pLoop )
{
cnt++;
pLoop = pLoop->next;
}
return ( cnt );
} |
ZStatus_t zclGeneral_RegisterCmdCallbacks( uint8 endpoint, zclGeneral_AppCallbacks_t *callbacks );
static zclGeneral_AppCallbacks_t *zclGeneral_FindCallbacks( uint8 endpoint );
static ZStatus_t zclGeneral_HdlIncoming( zclIncoming_t *pInMsg );
static ZStatus_t zclGeneral_HdlInSpecificCommands( zclIncoming_t *pInMsg );
static ZStatus_t zclGeneral_AddGroup( uint8 endPoint, aps_Group_t *group, uint8 *pData );
ZStatus_t zclGeneral_AddScene( uint8 endpoint, zclGeneral_Scene_t *scene );
zclGeneral_Scene_t *zclGeneral_FindScene( uint8 endpoint, uint16 groupID, uint8 sceneID );
uint8 zclGeneral_FindAllScenesForGroup( uint8 endpoint, uint16 groupID, uint8 *sceneList );
uint8 zclGeneral_RemoveScene( uint8 endpoint, uint16 groupID, uint8 sceneID );
void zclGeneral_RemoveAllScenes( uint8 endpoint, uint16 groupID );
uint8 zclGeneral_CountScenes( uint8 endpoint );
ZStatus_t zclGeneral_AddAlarm( uint8 endpoint, zclGeneral_Alarm_t *alarm );
zclGeneral_Alarm_t *zclGeneral_FindAlarm( uint8 endpoint, uint8 alarmCode, uint16 clusterID );
zclGeneral_Alarm_t *zclGeneral_FindEarliestAlarm( uint8 endpoint );
void zclGeneral_ResetAlarm( uint8 endpoint, uint8 alarmCode, uint16 clusterID );
void zclGeneral_ResetAllAlarms( uint8 endpoint, uint8 notifyApp );
static uint8 zclGeneral_ScenesInitNV( void );
static void zclGeneral_ScenesSetDefaultNV( void );
static void zclGeneral_ScenesWriteNV( void );
static uint16 zclGeneral_ScenesRestoreFromNV( void );
void zclGeneral_ScenesInit( void );
void zclGeneral_ScenesSave( void );
| 600d02cbb06437b5f64e7227b0f5aa5f9ad85630f6153450144e5308152497a1 | 202 |
|
osmocom | libosmocore | src/conv_acc_generic.c |
__attribute__ |
__attribute__ ((visibility("hidden")))
void osmo_conv_gen_metrics_k5_n2(const int8_t *seq, const int16_t *out,
int16_t *sums, int16_t *paths, int norm)
{
int16_t metrics[8];
gen_branch_metrics_n2(16, seq, out, metrics);
gen_path_metrics(16, sums, metrics, paths, norm);
} |
__attribute__ ((visibility("hidden");
__attribute__ ((visibility("hidden");
__attribute__ ((visibility("hidden");
__attribute__ ((visibility("hidden");
__attribute__ ((visibility("hidden");
__attribute__ ((visibility("hidden");
__attribute__ ((visibility("hidden");
| 4c60f63e2700357f8c81dd1a20b84f06348e2fd5289dd1ea84c6c41b1d19d9e3 | 277 |
|
itgb | opCloudRouter | qca/src/qca-hyfi-bridge/hyfi-netfilter/hyfi_seamless.c | hyfi_psw_process_pkt |
int hyfi_psw_process_pkt(struct net_hatbl_entry *ha, struct sk_buff **skb,
const struct hyfi_net_bridge *br)
{
struct sk_buff *pskb = *skb;
spin_lock(&ha->psw_info.buf_q_lock);
if (unlikely(ha->psw_info.dup_pkt || ha->psw_info.wait_idx >= 0)) {
if (*skb) {
kfree_skb(*skb);
*skb = NULL;
}
if (ha->psw_info.wait_idx < 0) {
ha->psw_info.dup_pkt--;
ha->psw_info.pkt_cnt++;
}
spin_unlock(&ha->psw_info.buf_q_lock);
return 1;
}
if (unlikely(
ha->psw_info.mse_timeout && pskb
&& ha->psw_info.buf_dev_idx != pskb->dev->ifindex)) {
kfree_skb(pskb);
*skb = NULL;
if (printk_ratelimit()) {
DPRINTK("Dropping packet from old interface %d\n",
pskb->dev->ifindex);
}
spin_unlock(&ha->psw_info.buf_q_lock);
return 1;
}
if (unlikely(
ha->psw_info.msb_rcv && !ha->psw_info.mse_rcv
&& !ha->psw_info.mse_timeout)) {
if (pskb && ha->psw_info.buf_dev_idx == pskb->dev->ifindex) {
struct hyfi_skb_buf_q *skb_buf_q;
struct hyfi_skb_buffer *hyfi_skb_buffer =
(struct hyfi_skb_buffer *) pskb->head;
if (likely(
time_before(jiffies, ha->psw_info.last_jiffies + br->path_switch_param.mse_timeout_val)
&& ha->psw_info.buf_pkt < HYFI_PSW_MAX_REORD_BUF)) {
hyfi_skb_buffer->skb = pskb;
skb_buf_q = &ha->psw_info.skb_buf_q;
TAILQ_INSERT_TAIL( skb_buf_q, hyfi_skb_buffer, skb_buf_qelem);
ha->psw_info.buf_pkt++;
if (*skb) {
*skb = NULL;
}
if (time_after( jiffies, ha->psw_info.old_if_jiffies + br->path_switch_param.old_if_quiet_timeout )) {
DPRINTK(
"Timeout waiting for switch end, old medium appears to be dead (jiffies=%lu, old_if_jiffies=%lu, timeout=%ums), forwarding %d buffered packets\n",
jiffies, ha->psw_info.old_if_jiffies, jiffies_to_msecs(br->path_switch_param.old_if_quiet_timeout), ha->psw_info.buf_pkt);
ha->psw_info.mse_timeout = 1;
ha->psw_info.old_if_jiffies = 0;
}
spin_unlock(&ha->psw_info.buf_q_lock);
return 1;
} else {
if (!ha->psw_info.mse_timeout) {
DPRINTK(
"Timeout waiting for switch end (jiffies=%lu, last_jiffies=%lu, timeout=%ums), forwarding %d buffered packets\n",
jiffies, ha->psw_info.last_jiffies, jiffies_to_msecs(br->path_switch_param.mse_timeout_val), ha->psw_info.buf_pkt);
ha->psw_info.mse_timeout = 1;
if (hyfi_psw_forward_and_queue(ha, skb)) {
spin_unlock(&ha->psw_info.buf_q_lock);
return 1;
}
}
}
} else {
ha->psw_info.old_if_jiffies = jiffies;
}
} else if (unlikely(!ha->psw_info.mse_rcv && ha->psw_info.buf_pkt)) {
if (hyfi_psw_forward_and_queue(ha, skb)) {
spin_unlock(&ha->psw_info.buf_q_lock);
return 1;
}
}
ha->psw_info.pkt_cnt++;
spin_unlock(&ha->psw_info.buf_q_lock);
return 0;
} |
void hyfi_psw_init(struct hyfi_net_bridge *br);
void hyfi_psw_stm_init(struct hyfi_net_bridge *br, struct net_hatbl_entry *ha);
void hyfi_psw_flush_track_q(struct ha_psw_stm_entry *pha_psw_stm_entry);
static psw_pkt_type hyfi_psw_detect_pkt(struct psw_pkt *psw_pkt);
int hyfi_psw_flush_buf_q(struct net_hatbl_entry *ha);
int hyfi_psw_flush_throt_q(struct net_hatbl_entry *ha);
int hyfi_psw_init_entry(struct net_hatbl_entry *ha);
| 437fceeae99a1aa6ae915b2ff6d001c752a194792c400ab70bbc3d9d3aa2ac3c | 2,773 |
|
ColumPaget | FileFerry | libUseful-2.0/http.c | HTTPParseHeader |
void HTTPParseHeader(STREAM *S, HTTPInfoStruct *Info, char *Header)
{
char *Token=NULL, *Tempstr=NULL;
int count=0;
int result;
char *ptr;
if (Info->Flags & HTTP_DEBUG) fprintf(stderr,"HEADER: %s\n",Header);
ptr=GetToken(Header,":",&Token,0);
while (isspace(*ptr)) ptr++;
Tempstr=MCopyStr(Tempstr,"HTTP:",Token,NULL);
STREAMSetValue(S,Tempstr,ptr);
ListAddNamedItem(Info->ServerHeaders,Token,CopyStr(NULL,ptr));
if (StrLen(Token) && StrLen(ptr))
{
switch (*Token)
{
case 'C':
case 'c':
if (strcasecmp(Token,"Content-length")==0)
{
Info->ContentLength=atoi(ptr);
}
else if (strcasecmp(Token,"Content-type")==0)
{
Info->ContentType=CopyStr(Info->ContentType,ptr);
}
else if (strcasecmp(Token,"Connection")==0)
{
if (strcasecmp(ptr,"Close")==0) Info->Flags &= ~HTTP_KEEPALIVE;
}
else if ((strcasecmp(Token,"Content-Encoding")==0) )
{
if (! (Info->Flags & HTTP_NODECODE))
{
strlwr(ptr);
if (
(strcmp(ptr,"gzip")==0) ||
(strcmp(ptr,"x-gzip")==0)
)
{
Info->Flags |= HTTP_GZIP;
}
if (
(strcmp(ptr,"deflate")==0)
)
{
Info->Flags |= HTTP_DEFLATE;
}
}
}
break;
case 'D':
case 'd':
if (strcasecmp(Token,"Date")==0) Info->Timestamp=CopyStr(Info->Timestamp,ptr);
break;
case 'L':
case 'l':
if (strcasecmp(Token,"Location")==0)
{
if (
(strncasecmp(ptr,"http:",5)==0) ||
(strncasecmp(ptr,"https:",6)==0)
)
{
Info->RedirectPath=CopyStr(Info->RedirectPath,ptr);
}
else Info->RedirectPath=FormatStr(Info->RedirectPath,"http:
}
break;
case 'W':
case 'w':
if (strcasecmp(Token,"WWW-Authenticate")==0) HTTPHandleWWWAuthenticate(Info,ptr);
break;
case 'S':
case 's':
if (strcasecmp(Token,"Set-Cookie")==0) HTTPParseCookie(Info,ptr);
else if (strcasecmp(Token,"Status")==0)
{
Info->ResponseCode=CopyStrLen(Info->ResponseCode,ptr,3);
STREAMSetValue(S,"HTTP:ResponseCode",Info->ResponseCode);
}
break;
case 'T':
case 't':
if (
(strcasecmp(Token,"Transfer-Encoding")==0)
)
{
if (! (Info->Flags & HTTP_NODECODE))
{
strlwr(ptr);
if (strstr(ptr,"chunked"))
{
Info->Flags |= HTTP_CHUNKED;
}
}
}
break;
}
}
DestroyString(Token);
DestroyString(Tempstr);
} |
void HTTPAuthSet(HTTPAuthStruct *Auth, char *Logon, char *Password, int Type);
void HTTPAuthDestroy(void *p_Auth);
void HTTPInfoDestroy(void *p_Info);
int HTTPChunkedInit(TProcessingModule *Mod, const char *Args);
int HTTPChunkedRead(TProcessingModule *Mod, const char *InBuff, int InLen, char **OutBuff, int *OutLen);
int HTTPChunkedClose(TProcessingModule *Mod);
void HTTPAddChunkedProcessor(STREAM *S);
char *HTTPUnQuote(char *RetBuff, char *Str);
char *HTTPQuoteChars(char *RetBuff, char *Str, char *CharList);
char *HTTPQuote(char *RetBuff, char *Str);
void HTTPInfoSetAuth(HTTPInfoStruct *Info, char *Logon, char *Password, int Type);
void HTTPInfoSetValues(HTTPInfoStruct *Info, char *Host, int Port, char *Logon, char *Password, char *Method, char *Doc, char *ContentType, int ContentLength);
HTTPInfoStruct *HTTPInfoCreate(char *Host, int Port, char *Logon, char *Password, char *Method, char *Doc, char *ContentType, int ContentLength);
char *HTTPInfoToURL(char *RetBuff, HTTPInfoStruct *Info);
HTTPInfoStruct *HTTPInfoFromURL(char *Method, char *URL);
void HTTPParseCookie(HTTPInfoStruct *Info, char *Str);
char *AppendCookies(char *InStr, ListNode *CookieList);
void HTTPHandleWWWAuthenticate(HTTPInfoStruct *Info, char *Line);
char *HTTPHeadersAppendAuth(char *RetStr, char *AuthHeader, HTTPInfoStruct *Info, HTTPAuthStruct *AuthInfo);
void HTTPSendHeaders(STREAM *S, HTTPInfoStruct *Info);
void HTTPReadHeaders(STREAM *S, HTTPInfoStruct *Info);
int HTTPProcessResponse(HTTPInfoStruct *HTTPInfo);
STREAM *HTTPSetupConnection(HTTPInfoStruct *Info, int ForceHTTPS);
STREAM *HTTPConnect(HTTPInfoStruct *Info);
STREAM *HTTPTransact(HTTPInfoStruct *Info);
STREAM *HTTPMethod(char *Method, char *URL, char *Logon, char *Password, char *ContentType, char *ContentData, int ContentLength);
STREAM *HTTPGet(char *URL, char *Logon, char *Password);
STREAM *HTTPPost(char *URL, char *Logon, char *Password, char *ContentType, char *Content);
void HTTPCopyToSTREAM(STREAM *Con, STREAM *S);
int HTTPDownload(char *URL,char *Login,char *Password, STREAM *S);
void HTTPSetUserAgent(char *AgentName);
void HTTPSetProxy(char *Proxy);
void HTTPSetFlags(int Flags);
int HTTPGetFlags();
| 09952bc6aff4343097d812a8b6ae6e67e60689f628165d7c4523d55559c1dba2 | 2,375 |
|
bhb27 | android_kernel_motorola_apq8084 | drivers/media/platform/msm/vidc/msm_vidc_debug.c | core_info_read |
static ssize_t core_info_read(struct file *file, char __user *buf,
size_t count, loff_t *ppos)
{
struct msm_vidc_core *core = file->private_data;
struct hfi_device *hdev;
int i = 0;
ssize_t len = 0;
if (!core || !core->device) {
dprintk(VIDC_ERR, "Invalid params, core: %pK\n", core);
return 0;
}
hdev = core->device;
mutex_lock(&dbg_buf.lock);
INIT_DBG_BUF(dbg_buf);
write_str(&dbg_buf, "===============================\n");
write_str(&dbg_buf, "CORE %d: 0x%pK\n", core->id, core);
write_str(&dbg_buf, "===============================\n");
write_str(&dbg_buf, "state: %d\n", core->state);
write_str(&dbg_buf, "base addr: 0x%x\n",
call_hfi_op(hdev, get_fw_info, hdev->hfi_device_data,
FW_BASE_ADDRESS));
write_str(&dbg_buf, "register_base: 0x%x\n",
call_hfi_op(hdev, get_fw_info, hdev->hfi_device_data,
FW_REGISTER_BASE));
write_str(&dbg_buf, "register_size: %u\n",
call_hfi_op(hdev, get_fw_info, hdev->hfi_device_data,
FW_REGISTER_SIZE));
write_str(&dbg_buf, "irq: %u\n",
call_hfi_op(hdev, get_fw_info, hdev->hfi_device_data,
FW_IRQ));
for (i = SYS_MSG_START; i < SYS_MSG_END; i++) {
write_str(&dbg_buf, "completions[%d]: %s\n", i,
completion_done(&core->completions[SYS_MSG_INDEX(i)]) ?
"pending" : "done");
}
len = simple_read_from_buffer(buf, count, ppos,
dbg_buf.ptr, dbg_buf.filled_size);
mutex_unlock(&dbg_buf.lock);
return len;
} |
static int core_info_open(struct inode *inode, struct file *file);
static u32 write_str(struct debug_buffer *buffer, const char *fmt, ...);
static int trigger_ssr_open(struct inode *inode, struct file *file);
struct dentry *msm_vidc_debugfs_init_drv(void);
static int inst_info_open(struct inode *inode, struct file *file);
static int publish_unreleased_reference(struct msm_vidc_inst *inst);
void msm_vidc_debugfs_deinit_drv(void);
| 6ad316cce8e5e4ae48fa5ac1867629c0444e448f36ecbf5ee9426479484844c9 | 1,407 |
|
linux4sam | gst1-hantro-g1 | sys/drmsink/gstframebuffersink.c | void
gst_framebuffersink_put_overlay_image_memcpy |
static void
gst_framebuffersink_put_overlay_image_memcpy (GstFramebufferSink *
framebuffersink, GstMemory * vmem, uint8_t * src)
{
GstFramebufferSinkClass *klass =
GST_FRAMEBUFFERSINK_GET_CLASS (framebuffersink);
uint8_t *framebuffer_address;
GstMapInfo mapinfo;
gboolean res;
mapinfo.data = NULL;
res = gst_memory_map (vmem, &mapinfo, GST_MAP_WRITE);
if (!res || mapinfo.data == NULL) {
GST_ERROR_OBJECT (framebuffersink, "Could not map video memory");
if (res)
gst_memory_unmap (vmem, &mapinfo);
return;
}
framebuffer_address = mapinfo.data;
if (framebuffersink->overlay_alignment_is_native)
memcpy (framebuffer_address, src, framebuffersink->video_info.size);
else {
int i;
int n = GST_VIDEO_INFO_N_PLANES (&framebuffersink->video_info);
guintptr offset;
for (i = 0; i < n; i++) {
offset = framebuffersink->overlay_plane_offset[i];
if (GST_VIDEO_INFO_PLANE_STRIDE (&framebuffersink->video_info, i) ==
framebuffersink->overlay_scanline_stride[i])
memcpy (framebuffer_address + offset, src,
framebuffersink->overlay_scanline_stride[i]
* framebuffersink->videosink.height);
else {
int y;
for (y = 0; y < framebuffersink->videosink.height; y++) {
memcpy (framebuffer_address + offset +
framebuffersink->overlay_scanline_offset[i],
src, framebuffersink->source_video_width_in_bytes[i]);
offset += framebuffersink->overlay_scanline_stride[i];
}
}
}
}
gst_memory_unmap (vmem, &mapinfo);
klass->show_overlay (framebuffersink, vmem);
} | e99bd5423bd2c5ac7b3aaf92f96d8ed2f9a8324bd4e61aac598ec8fb4de21983 | 1,649 |
||
goblinhack | MundusMeus | src/wid_console.c | wid_console_init |
uint8_t wid_console_init (void)
{
wid_console_inited = true;
command_add(debug_enable, "set debug [01]", "enable/disable debug mode");
command_add(fps_enable, "set fps [01]", "frames per sec counter");
command_add(sdl_user_exit, "quit", "exit game");
wid_console_wid_create();
return (true);
} |
void wid_console_fini (void);
static void wid_console_reset_scroll (void);
static void wid_console_log_ (const char *s);
void wid_console_log (const char *s);
uint8_t wid_console_receive_input (widp w, const SDL_KEYSYM *key);
static void wid_console_wid_create (void);
| f05433c5ea4284ce10610ca4ff90e244b3a49e60224f35530ca604cca622b47d | 323 |
|
317394245 | myplayer | ijkmedia/ijksdl/android/ijksdl_codec_android_mediaformat.c | SDL_AMediaFormat_setInt32 |
void SDL_AMediaFormat_setInt32(SDL_AMediaFormat* aformat, const char* name, int32_t value)
{
assert(aformat->func_setInt32);
aformat->func_setInt32(aformat, name, value);
} |
sdl_amedia_status_t SDL_AMediaFormat_delete(SDL_AMediaFormat* aformat);
sdl_amedia_status_t SDL_AMediaFormat_deleteP(SDL_AMediaFormat** aformat);
bool SDL_AMediaFormat_getInt32(SDL_AMediaFormat* aformat, const char* name, int32_t *out);
void SDL_AMediaFormat_setBuffer(SDL_AMediaFormat* aformat, const char* name, void* data, size_t size);
| f78cab8550983c1b3f239df549e452ce0f6425571c3667f50999bc03e9ced771 | 181 |
|
araca | Zen-Kernel-Huawei-P7 | drivers/misc/gpu_drv/hal/user/gc_hal_user_surface.c |
gceSTATUS
gcoSURF_GetSize |
gceSTATUS
gcoSURF_GetSize(
IN gcoSURF Surface,
OUT gctUINT * Width,
OUT gctUINT * Height,
OUT gctUINT * Depth
)
{
gcmHEADER_ARG("Surface=0x%x", Surface);
gcmVERIFY_OBJECT(Surface, gcvOBJ_SURF);
if (Width != gcvNULL)
{
*Width =
Surface->info.rect.right;
}
if (Height != gcvNULL)
{
*Height =
Surface->info.rect.bottom;
}
if (Depth != gcvNULL)
{
*Depth = Surface->depth;
}
gcmFOOTER_ARG("*Width=%u *Height=%u *Depth=%u",
(Width == gcvNULL) ? 0 : *Width,
(Height == gcvNULL) ? 0 : *Height,
(Depth == gcvNULL) ? 0 : *Depth);
return gcvSTATUS_OK;
} | abd4589b55948ce344cabc485c50fde9f9bbf22631bfcb5966cd892ab8bc3496 | 766 |
||
niketancm | tsea26 | lab4/sim.c | insn_logic_op |
static void insn_logic_op(uint32_t insn)
{
uint32_t opa, opb;
uint32_t result;
opa = get_opa(insn);
opb = get_opb(insn);
switch (insn & 0x07800000) {
case 0x00000000: result = opa & opb; break;
case 0x01000000: result = opa | opb; break;
case 0x02000000: result = opa ^ opb; break;
default: sim_warning("Unimplemented logic instruction"); return;
}
if(insn & 0x00800000) {
update_flags(result);
}
set_reg(get_dreg(insn),result,0);
} |
void sim_stop(void);
void sim_print_regs(void);
static void advance_cycles(int num);
static void repeat_sad_stop(int num);
static void check_access(unsigned int regnum);
static void check_sr_access(unsigned int regnum);
static int sx(unsigned int val, int bits);
static void update_flags(uint32_t result);
static int get_rega(uint32_t insn);
static int get_regb(uint32_t insn);
static int get_dreg(uint32_t insn);
static uint16_t get_reg(int regnum);
static uint16_t get_opa(uint32_t insn);
static uint16_t get_opb(uint32_t insn);
static uint16_t get_opd(uint32_t insn);
static void set_reg(unsigned int regnum, uint16_t regval, int delay);
static void sr_write(unsigned int reg,unsigned int val);
static uint16_t sr_read(unsigned int reg);
static void insn_load(uint32_t insn);
static void insn_moveloadstore(uint32_t insn);
static uint16_t abs16(uint16_t val);
static void insn_arithmetic_op(uint32_t insn);
static void insn_iterative_op(uint32_t insn);
static void insn_type01(uint32_t insn);
static int check_condition(uint32_t insn);
static void insn_pfc(uint32_t insn);
static void insn_accelerated(uint32_t insn);
static void advance_pc(void);
static void run_insn(void);
static void sim_run(int num_cycles);
static void sim_init(void);
static void load_images(void);
int main(int argc, char **argv);
| 9adca58e814880a1341b9d8a1480270cb07a431829ebf7647b9d5129f7603518 | 458 |
|
KeydownR | DTE | PROTEUS/sonde2.c | main |
void main()
{
setup_adc_ports(AN0);
set_adc_channel(0);
setup_adc(ADC_CLOCK_INTERNAL);
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1|RTCC_8_BIT);
setup_timer_1(T1_INTERNAL|T1_DIV_BY_1);
setup_low_volt_detect(FALSE);
enable_interrupts(GLOBAL);
int lastTemperature = -1000;
int currentTemperature;
printf("DTE.tresh:%d\r\n", treshld);
delay_ms(10);
while(TRUE) {
enable_interrupts(INT_RDA);
currentTemperature = read_adc() * CONV_CST;
checkLed(currentTemperature, treshld);
bitsToBCD(currentTemperature);
if (currentTemperature != lastTemperature) {
lastTemperature = currentTemperature;
printf("DTE.temp:%d\r\n", currentTemperature);
}
}
}
|
void isr();
int simpleBCDConverter(value);
void bitsToBCD(int value);
void checkLed(int temp, int treshld);
| 2623d51b22f9f45105a6511fa50e0d896cd40d806321363f886a04b6f019dbc3 | 838 |
|
bkuebler | openshift-apache-http-cartridge | spievatko/espievatko/prtbl/srv/httpd-2.4.9/server/listen.c | find_accf_name |
static const char* find_accf_name(server_rec *s, const char *proto)
{
const char* accf;
core_server_config *conf = ap_get_core_module_config(s->module_config);
if (!proto) {
return NULL;
}
accf = apr_table_get(conf->accf_map, proto);
if (accf && !strcmp("none", accf)) {
return NULL;
}
return accf;
} |
static apr_status_t make_sock(apr_pool_t *p, ap_listen_rec *server);
static apr_status_t close_listeners_on_exec(void *v);
static int open_listeners(apr_pool_t *pool);
AP_DECLARE(int);
AP_DECLARE_NONSTD(void);
AP_DECLARE_NONSTD(int);
AP_DECLARE(void);
AP_DECLARE_NONSTD(const char *);
AP_DECLARE_NONSTD(const char *);
AP_DECLARE_NONSTD(const char *);
AP_DECLARE_NONSTD(const char *);
| 6c956abeac7a6de3782d97eda54e7c9fb49b7a371c6aa46f20a3419163a7dba0 | 352 |
|
twobob | buildroot-kindle | output/build/dbus-1.4.24/dbus/dbus-string.c |
dbus_bool_t
_dbus_string_copy_data_len |
dbus_bool_t
_dbus_string_copy_data_len (const DBusString *str,
char **data_return,
int start,
int len)
{
DBusString dest;
DBUS_CONST_STRING_PREAMBLE (str);
_dbus_assert (data_return != NULL);
_dbus_assert (start >= 0);
_dbus_assert (len >= 0);
_dbus_assert (start <= real->len);
_dbus_assert (len <= real->len - start);
if (!_dbus_string_init (&dest))
return FALSE;
set_max_length (&dest, real->max_length);
if (!_dbus_string_copy_len (str, start, len, &dest, 0))
{
_dbus_string_free (&dest);
return FALSE;
}
if (!_dbus_string_steal_data (&dest, data_return))
{
_dbus_string_free (&dest);
return FALSE;
}
_dbus_string_free (&dest);
return TRUE;
} | 00e343c626eaae6d6ee32a62ebdccc21e101d35b6f0e85b9bba775e69f3596f0 | 850 |
||
pumpkin83 | OpenUH-OpenACC | osprey/libcaf/caf_rtl.c | __caf_finalize |
void __caf_finalize(int exit_code)
{
LIBCAF_TRACE(LIBCAF_LOG_EXIT, "entry");
PROFILE_FUNC_ENTRY(0);
LIBCAF_TRACE(LIBCAF_LOG_TIME_SUMMARY, "Accumulated Time:");
LIBCAF_TRACE(LIBCAF_LOG_MEMORY_SUMMARY, "\n\tHEAP USAGE: ");
CALLSITE_TRACE(EXIT, comm_finalize, exit_code);
PROFILE_FUNC_EXIT();
LIBCAF_TRACE(LIBCAF_LOG_EXIT, "exit");
} |
void __caf_init();
void __target_alloc(unsigned long buf_size, void **ptr);
void *__target_alloc2(unsigned long buf_size, void *orig_ptr);
void __target_dealloc(void **ptr);
void __acquire_lcb(unsigned long buf_size, void **ptr);
void __release_lcb(void **ptr);
void __coarray_sync(comm_handle_t hdl);
void __coarray_read(size_t image, void *src, void *dest, size_t nbytes);
void uhcaf_check_comms(void);
void __caf_exit(int status);
void _SYNC_ALL(int *status, int stat_len, char *errmsg, int errmsg_len);
void _CRITICAL();
void _END_CRITICAL();
void _ATOMIC_DEFINE_1(atomic_t * atom, INT1 * value, int *image);
void _ATOMIC_DEFINE_2(atomic_t * atom, INT2 * value, int *image);
void _ATOMIC_DEFINE_4(atomic_t * atom, INT4 * value, int *image);
void _ATOMIC_DEFINE_8(atomic_t * atom, INT8 * value, int *image);
void _ATOMIC_REF_1(INT1 * value, atomic_t * atom, int *image);
void _ATOMIC_REF_2(INT2 * value, atomic_t * atom, int *image);
void _ATOMIC_REF_4(INT4 * value, atomic_t * atom, int *image);
void _ATOMIC_REF_8(INT8 * value, atomic_t * atom, int *image);
void _EVENT_POST(event_t * event, int *image);
void _EVENT_QUERY(event_t * event, int *image, char *state, int state_len);
void _EVENT_WAIT(event_t * event, int *image);
void _SYNC_MEMORY(int *status, int stat_len, char *errmsg, int errmsg_len);
int _IMAGE_INDEX(DopeVectorType * diminfo, DopeVectorType * sub);
void _THIS_IMAGE1(DopeVectorType * ret, DopeVectorType * diminfo);
int _THIS_IMAGE2(DopeVectorType * diminfo, int *sub);
int _LCOBOUND_2(DopeVectorType * diminfo, int *sub);
void _LCOBOUND_1(DopeVectorType * ret, DopeVectorType * diminfo);
int _UCOBOUND_2(DopeVectorType * diminfo, int *sub);
void _UCOBOUND_1(DopeVectorType * ret, DopeVectorType * diminfo);
void coarray_translate_remote_addr(void **remote_addr, int image);
int check_remote_image(size_t image);
int check_remote_address(size_t image, void *address);
| 431ff235073eeaab310a9fcc98d91c8d89107701eb6733f1c931f988c314d91a | 370 |
|
kaleb-himes | wolfssl | wolfcrypt/src/rsa.c | wc_RsaPrivateDecryptInline |
int wc_RsaPrivateDecryptInline(byte* in, word32 inLen, byte** out, RsaKey* key)
{
WC_RNG* rng;
int ret;
#ifdef WC_RSA_BLINDING
rng = key->rng;
#else
rng = NULL;
#endif
SAVE_VECTOR_REGISTERS(return _svr_ret;);
ret = RsaPrivateDecryptEx(in, inLen, in, inLen, out, key,
RSA_PRIVATE_DECRYPT, RSA_BLOCK_TYPE_2, WC_RSA_PKCSV15_PAD,
WC_HASH_TYPE_NONE, WC_MGF1NONE, NULL, 0, 0, rng);
RESTORE_VECTOR_REGISTERS();
return ret;
} |
int wc_InitRsaKey(RsaKey* key, void* ptr);
int wc_InitRsaKey_ex(RsaKey* key, void* ptr, int devId);
int wc_FreeRsaKey(RsaKey* key);
int wc_RsaSSL_VerifyInline(byte* in, word32 inLen, byte** out, RsaKey* key);
int wc_RsaEncryptSize(const RsaKey* key);
int wc_MakeRsaKey(RsaKey* key, int size, long e, WC_RNG* rng);
static void wc_RsaCleanup(RsaKey* key);
int wc_InitRsaKey_ex(RsaKey* key, void* heap, int devId);
int wc_InitRsaKey(RsaKey* key, void* heap);
int wc_InitRsaKey_Label(RsaKey* key, const char* label, void* heap, int devId);
int wc_InitRsaHw(RsaKey* key);
int wc_InitRsaHw(RsaKey* key);
static int cc310_RSA_GenerateKeyPair(RsaKey* key, int size, long e);
int wc_RsaUseKeyId(RsaKey* key, word32 keyId, word32 flags);
int wc_RsaGetKeyId(RsaKey* key, word32* keyId);
int wc_FreeRsaKey(RsaKey* key);
int wc_CheckRsaKey(RsaKey* key);
int wc_hash2mgf(enum wc_HashType hType);
else if (rsa_type == RSA_PUBLIC_DECRYPT &&
pad_value == RSA_BLOCK_TYPE_1);
int wc_RsaSSL_VerifyInline(byte* in, word32 inLen, byte** out, RsaKey* key);
int wc_RsaEncryptSize(const RsaKey* key);
static int RsaGetValue(mp_int* in, byte* out, word32* outSz);
static int wc_CompareDiffPQ(mp_int* p, mp_int* q, int size, int* valid);
static WC_INLINE int RsaSizeCheck(int size);
int wc_MakeRsaKey(RsaKey* key, int size, long e, WC_RNG* rng);
int wc_RsaSetRNG(RsaKey* key, WC_RNG* rng);
int wc_RsaSetNonBlock(RsaKey* key, RsaNb* nb);
int wc_RsaSetNonBlockTime(RsaKey* key, word32 maxBlockUs, word32 cpuMHz);
| 4150a1a811642f0c779b70ac7c5729bf43a27d16c24d6f63dad02d6cd75b9965 | 466 |
|
WigWagCo | node-isc-dhclient | deps/isc-dhcp/bind/bind-expanded-tar/lib/dns/rdata/generic/ipseckey_45.c | isc_result_t
fromtext_ipseckey |
static inline isc_result_t
fromtext_ipseckey(ARGS_FROMTEXT) {
isc_token_t token;
dns_name_t name;
isc_buffer_t buffer;
unsigned int gateway;
struct in_addr addr;
unsigned char addr6[16];
isc_region_t region;
REQUIRE(type == 45);
UNUSED(type);
UNUSED(rdclass);
UNUSED(callbacks);
RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_number,
ISC_FALSE));
if (token.value.as_ulong > 0xffU)
RETTOK(ISC_R_RANGE);
RETERR(uint8_tobuffer(token.value.as_ulong, target));
RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_number,
ISC_FALSE));
if (token.value.as_ulong > 0x3U)
RETTOK(ISC_R_RANGE);
RETERR(uint8_tobuffer(token.value.as_ulong, target));
gateway = token.value.as_ulong;
RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_number,
ISC_FALSE));
if (token.value.as_ulong > 0xffU)
RETTOK(ISC_R_RANGE);
RETERR(uint8_tobuffer(token.value.as_ulong, target));
RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
ISC_FALSE));
switch (gateway) {
case 0:
if (strcmp(DNS_AS_STR(token), ".") != 0)
RETTOK(DNS_R_SYNTAX);
break;
case 1:
if (getquad(DNS_AS_STR(token), &addr, lexer, callbacks) != 1)
RETTOK(DNS_R_BADDOTTEDQUAD);
isc_buffer_availableregion(target, ®ion);
if (region.length < 4)
return (ISC_R_NOSPACE);
memmove(region.base, &addr, 4);
isc_buffer_add(target, 4);
break;
case 2:
if (inet_pton(AF_INET6, DNS_AS_STR(token), addr6) != 1)
RETTOK(DNS_R_BADAAAA);
isc_buffer_availableregion(target, ®ion);
if (region.length < 16)
return (ISC_R_NOSPACE);
memmove(region.base, addr6, 16);
isc_buffer_add(target, 16);
break;
case 3:
dns_name_init(&name, NULL);
buffer_fromregion(&buffer, &token.value.as_region);
origin = (origin != NULL) ? origin : dns_rootname;
RETTOK(dns_name_fromtext(&name, &buffer, origin,
options, target));
break;
}
return (isc_base64_tobuffer(lexer, target, -1));
} | cfeb7aa48c3f2e9b56002f510e0f6705df54deeedddb34beaf198f3ad3cbb7d3 | 1,986 |
||
CumulusNetworks | quagga | ospfd/ospf_flood.c |
int
ospf_flood_through_area |
int
ospf_flood_through_area (struct ospf_area *area,
struct ospf_neighbor *inbr, struct ospf_lsa *lsa)
{
struct listnode *node, *nnode;
struct ospf_interface *oi;
int lsa_ack_flag = 0;
for (ALL_LIST_ELEMENTS (area->oiflist, node, nnode, oi))
{
if (area->area_id.s_addr != OSPF_AREA_BACKBONE &&
oi->type == OSPF_IFTYPE_VIRTUALLINK)
continue;
if ((lsa->data->type == OSPF_OPAQUE_LINK_LSA) && (lsa->oi != oi))
{
if (IS_DEBUG_OSPF (lsa, LSA_FLOODING))
zlog_debug ("Type-9 Opaque-LSA: lsa->oi(%p) != oi(%p)",
(void *)lsa->oi, (void *)oi);
continue;
}
if (ospf_flood_through_interface (oi, inbr, lsa))
lsa_ack_flag = 1;
}
return (lsa_ack_flag);
}
int
ospf_flood_through_as (struct ospf *ospf, struct ospf_neighbor *inbr,
struct ospf_lsa *lsa)
{
struct listnode *node;
struct ospf_area *area;
int lsa_ack_flag;
lsa_ack_flag = 0;
if (CHECK_FLAG (lsa->flags, OSPF_LSA_LOCAL_XLT))
if (IS_DEBUG_OSPF_NSSA)
zlog_debug ("Flood/AS: NSSA TRANSLATED LSA");
for (ALL_LIST_ELEMENTS_RO (ospf->areas, node, area))
{
int continue_flag = 0;
struct listnode *if_node;
struct ospf_interface *oi;
switch (area->external_routing)
{
case OSPF_AREA_NSSA:
if (lsa->data->type == OSPF_AS_NSSA_LSA
&& area == lsa->area)
continue_flag = 0;
else
continue_flag = 1;
break;
case OSPF_AREA_TYPE_MAX:
case OSPF_AREA_STUB:
continue_flag = 1;
break;
case OSPF_AREA_DEFAULT:
default:
if (lsa->data->type == OSPF_AS_NSSA_LSA)
continue_flag = 1;
else
continue_flag = 0;
break;
}
if (continue_flag)
continue;
for (ALL_LIST_ELEMENTS_RO (area->oiflist, if_node, oi))
{
if (oi->type != OSPF_IFTYPE_VIRTUALLINK)
if (ospf_flood_through_interface (oi, inbr, lsa))
lsa_ack_flag = 1;
}
}
return (lsa_ack_flag);
}
int
ospf_flood_through (struct ospf *ospf,
struct ospf_neighbor *inbr, struct ospf_lsa *lsa)
{
int lsa_ack_flag = 0;
#ifdef ORIGINAL_CODING
switch (lsa->data->type)
{
case OSPF_ROUTER_LSA:
case OSPF_NETWORK_LSA:
case OSPF_SUMMARY_LSA:
case OSPF_ASBR_SUMMARY_LSA:
case OSPF_OPAQUE_LINK_LSA:
case OSPF_OPAQUE_AREA_LSA:
lsa_ack_flag = ospf_flood_through_area (inbr->oi->area, inbr, lsa);
break;
case OSPF_AS_EXTERNAL_LSA:
case OSPF_OPAQUE_AS_LSA:
lsa_ack_flag = ospf_flood_through_as (ospf, inbr, lsa);
break;
case OSPF_AS_NSSA_LSA:
lsa_ack_flag = ospf_flood_through_area (inbr->oi->area, inbr, lsa);
if (IS_DEBUG_OSPF_NSSA)
zlog_debug ("ospf_flood_through: LOCAL NSSA FLOOD of Type-7.");
break;
default:
break;
}
#else
switch (lsa->data->type)
{
case OSPF_AS_EXTERNAL_LSA:
case OSPF_OPAQUE_AS_LSA:
lsa_ack_flag = ospf_flood_through_as (ospf, inbr, lsa);
break;
case OSPF_AS_NSSA_LSA:
if (IS_DEBUG_OSPF_NSSA)
zlog_debug ("ospf_flood_through: LOCAL NSSA FLOOD of Type-7.");
default:
lsa_ack_flag = ospf_flood_through_area (lsa->area, inbr, lsa);
break;
}
#endif
return (lsa_ack_flag);
} | 50e1bea4b863029bcf5c9dd9343fb3a9a96d3c70b08b46b41375cbb180925eb1 | 3,400 |
||
LiberatorUSA | GUCEF | dependencies/agar/gui/drv_sdlfb.c | void
SDLFB_FillRect |
static void
SDLFB_FillRect(void *obj, AG_Rect r, AG_Color c)
{
AG_DriverSDLFB *sfb = obj;
SDL_Rect sr;
sr.x = r.x;
sr.y = r.y;
sr.w = r.w;
sr.h = r.h;
SDL_FillRect(sfb->s, &sr,
SDL_MapRGB(sfb->s->format, c.r, c.g, c.b));
} | c0e2d539de92de885a0a3bea790a4afc1e7c8a2d24b103f953de3f00390beb64 | 236 |
||
durandj | devkitadv | insight-5.3/gdb/dwarfread.c | int
attribute_size |
static int
attribute_size (unsigned int attr)
{
int nbytes;
unsigned short form;
form = FORM_FROM_ATTR (attr);
switch (form)
{
case FORM_STRING:
nbytes = 0;
break;
case FORM_DATA2:
case FORM_BLOCK2:
nbytes = 2;
break;
case FORM_DATA4:
case FORM_BLOCK4:
case FORM_REF:
nbytes = 4;
break;
case FORM_DATA8:
nbytes = 8;
break;
case FORM_ADDR:
nbytes = TARGET_FT_POINTER_SIZE (objfile);
break;
default:
complain (&unknown_attribute_form, DIE_ID, DIE_NAME, form);
nbytes = -1;
break;
}
return (nbytes);
} | 3c0b97f1cd40f586e833471041722ad5bdab8ebac1f4530ea29e546ae868bc9e | 663 |
||
JianpingZeng | xcc | samples/Juliet/testcases/CWE197_Numeric_Truncation_Error/s01/CWE197_Numeric_Truncation_Error__int_large_to_char_22b.c | CWE197_Numeric_Truncation_Error__int_large_to_char_22_goodG2B1Source |
int CWE197_Numeric_Truncation_Error__int_large_to_char_22_goodG2B1Source(int data)
{
if(CWE197_Numeric_Truncation_Error__int_large_to_char_22_goodG2B1Global)
{
printLine("Benign, fixed string");
}
else
{
data = CHAR_MAX-5;
}
return data;
} |
int CWE197_Numeric_Truncation_Error__int_large_to_char_22_badSource(int data);
int CWE197_Numeric_Truncation_Error__int_large_to_char_22_goodG2B2Source(int data);
| 6b3ab6efbc499b8b83d74ed070cae8057ca4ada8650f5b3f114e361f5c073466 | 317 |
|
nkremerh | cctools | makeflow/src/makeflow.c | makeflow_run |
static void makeflow_run( struct dag *d )
{
struct dag_node *n;
batch_job_id_t jobid;
struct batch_job_info info;
timestamp_t start = timestamp_get();
timestamp_t last_time = start - (60 * 1000 * 1000);
if(catalog_reporting_on){
makeflow_catalog_summary(d, project, batch_queue_type, start);
}
while(!makeflow_abort_flag) {
makeflow_dispatch_ready_jobs(d);
if(dag_local_jobs_running(d)==0 &&
dag_remote_jobs_running(d)==0 &&
(makeflow_hook_dag_loop(d) == MAKEFLOW_HOOK_END) &&
makeflow_nodes_remote_waiting_count(d) == 0) {
break;
}
if(dag_remote_jobs_running(d)) {
int tmp_timeout = 5;
jobid = batch_job_wait_timeout(remote_queue, &info, time(0) + tmp_timeout);
if(jobid > 0) {
printf("job %"PRIbjid" completed\n",jobid);
debug(D_MAKEFLOW_RUN, "Job %" PRIbjid " has returned.\n", jobid);
n = itable_remove(d->remote_job_table, jobid);
if(n){
batch_task_set_info(n->task, &info);
makeflow_node_complete(d, n, remote_queue, n->task);
}
}
}
if(dag_local_jobs_running(d)) {
time_t stoptime;
int tmp_timeout = 5;
if(dag_remote_jobs_running(d)) {
stoptime = time(0);
} else {
stoptime = time(0) + tmp_timeout;
}
jobid = batch_job_wait_timeout(local_queue, &info, stoptime);
if(jobid > 0) {
debug(D_MAKEFLOW_RUN, "Job %" PRIbjid " has returned.\n", jobid);
n = itable_remove(d->local_job_table, jobid);
if(n){
batch_task_set_info(n->task, &info);
makeflow_node_complete(d, n, local_queue, n->task);
}
}
}
timestamp_t now = timestamp_get();
if(catalog_reporting_on && ((now-last_time) > (60 * 1000 * 1000))){
makeflow_catalog_summary(d, project,batch_queue_type,start);
last_time = now;
}
makeflow_gc_barrier--;
if(makeflow_gc_method != MAKEFLOW_GC_NONE && makeflow_gc_barrier == 0) {
makeflow_gc(d, remote_queue, makeflow_gc_method, makeflow_gc_size, makeflow_gc_count);
makeflow_gc_barrier = MAX(d->nodeid_counter * makeflow_gc_task_ratio, 1);
}
}
if(catalog_reporting_on){
makeflow_catalog_summary(d, project,batch_queue_type,start);
}
if(makeflow_abort_flag) {
makeflow_abort_all(d);
} else if(!makeflow_failed_flag && makeflow_gc_method != MAKEFLOW_GC_NONE) {
makeflow_gc(d,remote_queue,MAKEFLOW_GC_ALL,0,0);
}
} |
struct batch_queue * makeflow_get_remote_queue();
struct batch_queue * makeflow_get_local_queue();
struct batch_queue * makeflow_get_queue(struct dag_node *n);
static int is_local_job( struct dag_node *n );
struct batch_task *makeflow_node_to_task(struct dag_node *n, struct batch_queue *queue );
static void makeflow_abort_job( struct dag *d, struct dag_node *n, struct batch_queue *q, uint64_t jobid, const char *name );
static void makeflow_abort_all(struct dag *d);
void makeflow_node_reset( struct dag *d, struct dag_node *n );
static void makeflow_node_reset_by_file( struct dag *d, struct dag_file *f );
void makeflow_node_decide_reset( struct dag *d, struct dag_node *n, int silent );
static enum job_submit_status makeflow_node_submit_retry( struct batch_queue *queue, struct batch_task *task);
static enum job_submit_status makeflow_node_submit(struct dag *d, struct dag_node *n, const struct rmsummary *resources);
static int makeflow_node_ready(struct dag *d, struct dag_node *n, const struct rmsummary *resources);
int makeflow_nodes_local_waiting_count(const struct dag *d);
int makeflow_nodes_remote_waiting_count(const struct dag *d);
static void makeflow_dispatch_ready_jobs(struct dag *d);
int makeflow_node_check_file_was_created(struct dag *d, struct dag_node *n, struct dag_file *f);
static void makeflow_node_complete(struct dag *d, struct dag_node *n, struct batch_queue *queue, struct batch_task *task);
static int makeflow_check_files(struct dag *d);
static int makeflow_check_batch_consistency(struct dag *d);
static void handle_abort(int sig);
static void show_help_run(const char *cmd);
int main(int argc, char *argv[]);
| 47dc31b9f4f171fa82e4e55c526ca31a45a8fda11f227852ef076b07c96f1bd0 | 2,338 |
|
jku | telepathy-gabble | src/ft-channel.c | void
connection_presences_updated_cb |
static void
connection_presences_updated_cb (GabblePresenceCache *cache,
GArray *handles,
GabbleFileTransferChannel *self)
{
guint i;
for (i = 0; i < handles->len ; i++)
{
TpHandle handle;
handle = g_array_index (handles, TpHandle, i);
if (handle == self->priv->handle)
{
GabblePresence *presence;
presence = gabble_presence_cache_get (
self->priv->connection->presence_cache, handle);
if (presence == NULL || presence->status < GABBLE_PRESENCE_XA)
{
if (self->priv->state != TP_FILE_TRANSFER_STATE_COMPLETED &&
self->priv->state != TP_FILE_TRANSFER_STATE_CANCELLED)
{
DEBUG ("peer disconnected. FileTransfer is cancelled");
gabble_file_transfer_channel_set_state (
TP_SVC_CHANNEL_TYPE_FILE_TRANSFER (self),
TP_FILE_TRANSFER_STATE_CANCELLED,
TP_FILE_TRANSFER_STATE_CHANGE_REASON_REMOTE_STOPPED);
}
}
}
}
} | 87373bafbb66935189e241dfb9493fde4561b6a0720f8f7528fe02e1ac0174cc | 1,173 |
||
Daimas | elygo-bots | gnugo/src/main/jni/gnugo-3.8/patterns/owl_attackpat.c | int
autohelperowl_attackpat295 |
static int
autohelperowl_attackpat295(int trans, int move, int color, int action)
{
int a, B;
UNUSED(color);
UNUSED(action);
a = AFFINE_TRANSFORM(721, trans, move);
B = AFFINE_TRANSFORM(720, trans, move);
return countlib(a) == 1 && owl_escape_value(B) > 0;
} | d3cdf73f94d485a82f21a8b2a9d85f67656fc597d3d05112c209fc3ecd34fd9a | 274 |
||
javiercantero | lincity | screen.c |
void
screen_full_refresh |
void
screen_full_refresh (void)
{
screen_refreshing++;
draw_background ();
monthgraph_full_refresh ();
mps_redraw ();
pbars_full_refresh ();
mini_full_refresh ();
if (selected_module_type == CST_GREEN)
draw_main_window_box (red (8));
else
draw_main_window_box (green (8));
draw_menu ();
draw_help ();
#if defined (commentout)
draw_load ();
draw_save ();
draw_quit ();
draw_help ();
#endif
draw_pause (pause_flag);
draw_slow (slow_flag & !pause_flag);
draw_med (med_flag & !pause_flag);
draw_fast (fast_flag & !pause_flag);
draw_results ();
draw_modules ();
if (help_flag) {
refresh_help_page ();
}
refresh_main_screen ();
print_date();
print_time_for_year();
print_total_money();
draw_selected_module_cost();
refresh_pbars();
redraw_mouse();
screen_refreshing--;
} | 24e3cf4fc1cb7d9d915ebb4c34b4544162ecf0ee26019941c8dd066946731b05 | 918 |
||
arm10c | linux | kernel/mutex.c | __mutex_trylock_slowpath | ck whether we
* can get the lock:
*/
static inline int __mutex_trylock_slowpath(atomic_t *lock_count)
{
struct mutex *lock = container_of(lock | *lock, const char *name, struct lock_class_key *key);
mutex *lock);
truct mspin_node *node);
spin_node *node);
task_struct *owner);
struct task_struct *owner);
k);
utex *lock, struct ww_acquire_ctx *ctx);
w_mutex *ww,
struct ww_acquire_ctx *ww_ctx);
truct ww_mutex *lock,
struct ww_acquire_ctx *ctx);
TASK_KILLABLE,
subclass, NULL, _RET_IP_, NULL);
tex_lock_common(lock, TASK_INTERRUPTIBLE,
subclass, NULL, _RET_IP_, NULL);
x *ctx);
tx->acquired > 1);
nt: &(&cpu_add_remove_lock);
nested, _RET_IP_);
__sched
__mutex_lock_slowpath(atomic_t *lock_count);
IP_, NULL);
NTERRUPTIBLE, 0,
NULL, _RET_IP_, ctx);
count);
mutex_acquire(&lock->dep_map, 0, 1, _RET_IP_);
wait_lock, flags);
lock();
utex_set_context_fastpath(lock, ctx);
t hit 0, so take the lock */
mutex_lock(lock);
| 0717322cae5d6e0058f4640319f35bd3e8bfbae1d89eea5e10a7c8e20433a866 | 145 |
|
Reinis | openbabel | openbabel-2.4.1/src/formats/libinchi/inchi_dll.c | AddMOLfileError |
int AddMOLfileError( char *pStrErr, const char *szMsg )
{
if ( pStrErr && szMsg && szMsg[0] ) {
int lenStrErr = strlen( pStrErr );
int lenMsg = strlen( szMsg );
char *p = strstr( pStrErr, szMsg );
if ( p && (p==pStrErr || (*(p-1) == ' ' && (*(p-2) == ';' || *(p-2) == ':' ))) &&
(p+lenMsg == pStrErr+lenStrErr ||
(p[lenMsg] == ';' && p[lenMsg+1] == ' ') ||
(p[lenMsg-1]==':' && p[lenMsg]==' ')) ) {
return 1;
}
if ( lenStrErr + lenMsg + 2*(lenStrErr > 0) < STR_ERR_LEN ) {
if (lenStrErr > 0) {
if ( pStrErr[lenStrErr-1] != ':' ) {
strcat( pStrErr, ";" );
}
strcat( pStrErr, " " );
}
strcat( pStrErr, szMsg );
return 1;
}
if ( strstr( pStrErr, "..." ) ) {
return 0;
}
if ( lenStrErr + 3 < STR_ERR_LEN ) {
strcat( pStrErr, "..." );
}
}
return 0;
} | void INCHI_DECL FreeINCHI( inchi_Output *out );
void INCHI_DECL FreeStdINCHI( inchi_Output *out );
void INCHI_DECL FreeStructFromStdINCHI( inchi_OutputStruct *out );
void INCHI_DECL FreeStructFromINCHI( inchi_OutputStruct *out );
int INCHI_DECL GetStdINCHI( inchi_Input *inp, inchi_Output *out );
int INCHI_DECL GetINCHI( inchi_Input *inp, inchi_Output *out );
static int GetINCHI1(inchi_Input *inp, inchi_Output *out, int bStdFormat);
int INCHI_DECL CheckINCHI(const char *szINCHI, const int strict);
void SetNumImplicitH(inp_ATOM* at, int num_atoms);
void FreeInpAtom( inp_ATOM **at );
inp_ATOM *CreateInpAtom( int num_atoms );
void FreeInpAtomData( INP_ATOM_DATA *inp_at_data );
int CreateInpAtomData( INP_ATOM_DATA *inp_at_data, int num_atoms, int create_at_fixed_bonds );
void FreeCompAtomData( COMP_ATOM_DATA *inp_at_data );
int CopyInpAtomData( INP_ATOM_DATA *dest_inp_at_data, INP_ATOM_DATA *src_inp_at_data );
void RenumbInpAtomData( INP_ATOM_DATA *dest_inp_at_data, INP_ATOM_DATA *src_inp_at_data, AT_RANK *new_ord );
void MakeNewOrd( int num_atoms, AT_RANK *new_ord );
void FreeOrigAtData( ORIG_ATOM_DATA *orig_at_data );
int parse_options_string ( char *cmd, const char *argv[], int maxargs );
int SetAtomProperties( inp_ATOM *at, MOL_COORD *szCoord, inchi_Atom *ati, int a1, int *nDim, char *pStrErr, int *err );
int InpAtom0DToInchiAtom( inp_ATOM *at, int num_atoms, inchi_OutputStruct *outStruct );
int INCHI_DECL GetStringLength( char *p );
int INCHI_DECL GetINCHIfromINCHI( inchi_InputINCHI *inpInChI, inchi_Output *out );
int INCHI_DECL GetStructFromStdINCHI( inchi_InputINCHI *inpInChI, inchi_OutputStruct *outStruct );
int INCHI_DECL GetStructFromINCHI( inchi_InputINCHI *inpInChI, inchi_OutputStruct *outStruct );
int cdecl_GetINCHI( inchi_Input *inp, inchi_Output *out );
int cdecl_GetStdINCHI( inchi_Input *inp, inchi_Output *out );
void cdecl_FreeINCHI( inchi_Output *out );
void cdecl_FreeStdINCHI( inchi_Output *out );
int cdecl_GetStringLength( char *p );
void cdecl_Free_std_inchi_Input( inchi_Input *pInp );
void cdecl_Free_inchi_Input( inchi_Input *pInp );
int cdecl_GetStructFromINCHI( inchi_InputINCHI *inpInChI, inchi_OutputStruct *outStruct );
int cdecl_GetStructFromStdINCHI( inchi_InputINCHI *inpInChI, inchi_OutputStruct *outStruct );
void cdecl_FreeStructFromINCHI( inchi_OutputStruct *outStruct );
int cdecl_GetINCHIfromINCHI( inchi_InputINCHI *inpInChI, inchi_Output *out );
void cdecl_FreeStructFromStdINCHI( inchi_OutputStruct *outStruct );
int cdecl_CheckINCHI(const char *szINCHI, const int strict);
int PASCAL pasc_GetINCHI( inchi_Input *inp, inchi_Output *out );
int PASCAL pasc_GetStdINCHI( inchi_Input *inp, inchi_Output *out );
void PASCAL pasc_FreeINCHI( inchi_Output *out );
void PASCAL pasc_FreeStdINCHI( inchi_Output *out );
int PASCAL pasc_GetStringLength( char *p );
void PASCAL pasc_Free_inchi_Input( inchi_Input *pInp );
void PASCAL pasc_Free_std_inchi_Input( inchi_Input *pInp );
void PASCAL pasc_FreeStructFromINCHI( inchi_OutputStruct *out );
void PASCAL pasc_FreeStructFromStdINCHI( inchi_OutputStruct *out );
int PASCAL pasc_GetStructFromINCHI( inchi_InputINCHI *inp, inchi_OutputStruct *out );
int PASCAL pasc_GetStructFromStdINCHI( inchi_InputINCHI *inp, inchi_OutputStruct *out );
int PASCAL pasc_CheckINCHI(const char *szINCHI, const int strict);
| b482b8b5cf9eb44ab5f5c22c05a498e61051551401d08b576a7edc994ee646ae | 1,084 |
|
marcomaggi | ccexceptions | tests/condition-subtyping-math-infinity-cclib.c |
void
cclib_exceptional_condition_descriptor_set_parent_to |
void
cclib_exceptional_condition_descriptor_set_parent_to(my_math_infinity_subtype) (cce_descriptor_t * const D)
{
D->parent = cclib_exceptional_condition_descriptor_pointer(my_math_infinity_subtype);
} | 66c16bc79b879526f5a35231754b4c6aaa16e25dd8c5c031b48fd4452aeb0c8a | 205 |
||
jyi | ITSP | dataset/Lab-6/2938/280726_correct.c | main |
int main() {
int a[20];
int N;
int i;
scanf("%d",&N);
for(i=0;i<N;i++)
{
scanf("%d",&a[i]);
}
int sum,l,j,k;
scanf("%d",&k);
for(j=0;j<=N-k;j++)
{
sum=0;
for(l=0;l<k;l=l+1)
{
sum=sum+a[j+l];
}
printf("%d\n",sum);
}
return 0;
} | defb87edc65ab0de5a2c8c64a5bb1fc7d07de9320521821ee47e65c60358c889 | 303 |
||
GEEK-IOT | SparkleBike | 2-Coding/1-ESP8266/ESP8266_FIRMWARE/ESP8266_NONOS_SDK/app/cosmart/device/ssd1306.c | executeDefaultSetup | E_FLASH_ATTR executeDefaultSetup() {
int i = 0;
bool isSuccess = false;
for (i = 0; i < SLAVE_DEVICE_COUNT; i ++) {
if (mDeviceList[i] != NULL) {
resetDevice(mDeviceList[i]);
}
}
}
LOCA | ICACHE_FLASH_ATTR SSD1306_initialize();
CACHE_FLASH_ATTR SSD1306_getSlaveDeviceCount();
CACHE_FLASH_ATTR SSD1306_getValidSlaveDeviceCount();
ICACHE_FLASH_ATTR SSD1306_bindDevice(int index);
ICACHE_FLASH_ATTR SSD1306_drawPixels(uint16 x, uint16 y, uint16 width, uint16 height, const uint8* pixels);
ICACHE_FLASH_ATTR SSD1306_drawBuffer(uint16 startColumn, uint16 endColumn, uint16 startPage, uint16 endPage, const uint8* buffer);
ICACHE_FLASH_ATTR SSD1306_drawText(char* text, uint16 x, uint16 y);
ICACHE_FLASH_ATTR SSD1306_erase(uint16 x, uint16 y, uint16 width, uint16 height);
ICACHE_FLASH_ATTR SSD1306_cleanScreen();
ICACHE_FLASH_ATTR SSD1306_flush();
ICACHE_FLASH_ATTR SSD1306_reset();
E_FLASH_ATTR testDeviceAddress();
E_FLASH_ATTR resetDevice(SSD1306Device* device);
E_FLASH_ATTR beginCMD(SSD1306Device* device);
E_FLASH_ATTR writeCMD_1(SSD1306Device* device, uint8 cmdA);
E_FLASH_ATTR writeCMD_2(SSD1306Device* device, uint8 cmdA, uint8 cmdB);
E_FLASH_ATTR writeCMD_3(SSD1306Device* device, uint8 cmdA, uint8 cmdB, uint8 cmdC);
E_FLASH_ATTR endCMD(SSD1306Device* device);
E_FLASH_ATTR beginRAM(SSD1306Device* device, uint8 colStart, uint8 colEnd, uint8 pageStart, uint8 pageEnd);
E_FLASH_ATTR writeRAM(SSD1306Device* device, uint8* data, uint16 dataLength);
E_FLASH_ATTR endRAM(SSD1306Device* device);
E_FLASH_ATTR flushFrameBuffer(SSD1306Device* device);
uint8 getDeviceReadAddress(SSD1306Device* device);
uint8 getDeviceWriteAddress(SSD1306Device* device);
| 83362c0168942a81a098f7c0a88e57f8cba9f01c4f36beeee3a7241ca2d8746a | 206 |
|
krzychb | rtd-test-bed | components/coap/libcoap/ext/tinydtls/dtls.c | int
calculate_key_block |
static int
calculate_key_block(dtls_context_t *ctx,
dtls_handshake_parameters_t *handshake,
dtls_peer_t *peer,
session_t *session,
dtls_peer_type role) {
(void) ctx;
(void) session;
unsigned char *pre_master_secret;
int pre_master_len = 0;
dtls_security_parameters_t *security = dtls_security_params_next(peer);
uint8 master_secret[DTLS_MASTER_SECRET_LENGTH];
(void)role;
if (!security) {
return dtls_alert_fatal_create(DTLS_ALERT_INTERNAL_ERROR);
}
pre_master_secret = security->key_block;
switch (handshake->cipher) {
#ifdef DTLS_PSK
case TLS_PSK_WITH_AES_128_CCM_8: {
unsigned char psk[DTLS_PSK_MAX_KEY_LEN];
int len;
len = CALL(ctx, get_psk_info, session, DTLS_PSK_KEY,
handshake->keyx.psk.identity,
handshake->keyx.psk.id_length,
psk, DTLS_PSK_MAX_KEY_LEN);
if (len < 0) {
dtls_crit("no psk key for session available\n");
return len;
}
pre_master_len = dtls_psk_pre_master_secret(psk, len,
pre_master_secret,
MAX_KEYBLOCK_LENGTH);
dtls_debug_hexdump("psk", psk, len);
memset(psk, 0, DTLS_PSK_MAX_KEY_LEN);
if (pre_master_len < 0) {
dtls_crit("the psk was too long, for the pre master secret\n");
return dtls_alert_fatal_create(DTLS_ALERT_INTERNAL_ERROR);
}
break;
}
#endif
#ifdef DTLS_ECC
case TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8: {
pre_master_len = dtls_ecdh_pre_master_secret(handshake->keyx.ecdsa.own_eph_priv,
handshake->keyx.ecdsa.other_eph_pub_x,
handshake->keyx.ecdsa.other_eph_pub_y,
sizeof(handshake->keyx.ecdsa.own_eph_priv),
pre_master_secret,
MAX_KEYBLOCK_LENGTH);
if (pre_master_len < 0) {
dtls_crit("the curve was too long, for the pre master secret\n");
return dtls_alert_fatal_create(DTLS_ALERT_INTERNAL_ERROR);
}
break;
}
#endif
case TLS_NULL_WITH_NULL_NULL:
assert(!"calculate_key_block: tried to use NULL cipher\n");
return dtls_alert_fatal_create(DTLS_ALERT_INSUFFICIENT_SECURITY);
#ifndef DTLS_PSK
case TLS_PSK_WITH_AES_128_CCM_8:
#endif
#ifndef DTLS_ECC
case TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8:
#endif
default:
dtls_crit("calculate_key_block: unknown cipher %x04 \n", handshake->cipher);
return dtls_alert_fatal_create(DTLS_ALERT_INTERNAL_ERROR);
}
dtls_debug_dump("client_random", handshake->tmp.random.client, DTLS_RANDOM_LENGTH);
dtls_debug_dump("server_random", handshake->tmp.random.server, DTLS_RANDOM_LENGTH);
dtls_debug_dump("pre_master_secret", pre_master_secret, pre_master_len);
dtls_prf(pre_master_secret, pre_master_len,
PRF_LABEL(master), PRF_LABEL_SIZE(master),
handshake->tmp.random.client, DTLS_RANDOM_LENGTH,
handshake->tmp.random.server, DTLS_RANDOM_LENGTH,
master_secret,
DTLS_MASTER_SECRET_LENGTH);
dtls_debug_dump("master_secret", master_secret, DTLS_MASTER_SECRET_LENGTH);
dtls_prf(master_secret,
DTLS_MASTER_SECRET_LENGTH,
PRF_LABEL(key), PRF_LABEL_SIZE(key),
handshake->tmp.random.server, DTLS_RANDOM_LENGTH,
handshake->tmp.random.client, DTLS_RANDOM_LENGTH,
security->key_block,
dtls_kb_size(security, role));
memcpy(handshake->tmp.master_secret, master_secret, DTLS_MASTER_SECRET_LENGTH);
dtls_debug_keyblock(security);
security->cipher = handshake->cipher;
security->compression = handshake->compression;
security->rseq = 0;
return 0;
} |
static inline void free_context(dtls_context_t *context);
static inline int is_tls_ecdhe_ecdsa_with_aes_128_ccm_8(dtls_cipher_t cipher);
static inline int is_tls_psk_with_aes_128_ccm_8(dtls_cipher_t cipher);
static inline int is_psk_supported(dtls_context_t *ctx);
static inline int is_ecdsa_supported(dtls_context_t *ctx, int is_client);
static inline int is_ecdsa_client_auth_supported(dtls_context_t *ctx);
static void dtls_debug_keyblock(dtls_security_parameters_t *config);
static char *dtls_handshake_type_to_name(int type);
static int verify_ext_eliptic_curves(uint8 *data, size_t data_length);
static int verify_ext_cert_type(uint8 *data, size_t data_length);
static int verify_ext_ec_point_formats(uint8 *data, size_t data_length);
| adf7d0a4cb8e8b5769f25dd826e76197005e8e7b4fff8accf72c283afeb149ec | 3,464 |
|
marcandrysco | AltC | src/posix/net.c | _socket_open |
_export
_socket_t _socket_open(uint16_t port)
{
_socket_t sock;
struct sockaddr_in addr;
sock = socket(AF_INET, SOCK_STREAM, 0);
if(sock < 0)
throw("Failed to bind. %s.", strerror(errno));
setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, mem_getref(int, 1), sizeof(int));
mem_zero(&addr, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = INADDR_ANY;
addr.sin_port = htons(port);
if(bind(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0)
throw("Failed to bind. %s.", strerror(errno));
return sock;
} | 59962c063b70b8bff4c76414fb5e26d9f0bb38cd6fa0d0688aec493c22d376f2 | 529 |
||
OpenLD | linux-wetek-3.10.y | drivers/amlogic/wifi/rtl8189ES/core/rtw_xmit.c |
s32 _rtw_init_xmit_priv |
s32 _rtw_init_xmit_priv(struct xmit_priv *pxmitpriv, _adapter *padapter)
{
int i;
struct xmit_buf *pxmitbuf;
struct xmit_frame *pxframe;
sint res=_SUCCESS;
u32 max_xmit_extbuf_size = MAX_XMIT_EXTBUF_SZ;
u32 num_xmit_extbuf = NR_XMIT_EXTBUFF;
_func_enter_;
_rtw_spinlock_init(&pxmitpriv->lock);
_rtw_spinlock_init(&pxmitpriv->lock_sctx);
_rtw_init_sema(&pxmitpriv->xmit_sema, 0);
_rtw_init_sema(&pxmitpriv->terminate_xmitthread_sema, 0);
pxmitpriv->adapter = padapter;
_rtw_init_queue(&pxmitpriv->be_pending);
_rtw_init_queue(&pxmitpriv->bk_pending);
_rtw_init_queue(&pxmitpriv->vi_pending);
_rtw_init_queue(&pxmitpriv->vo_pending);
_rtw_init_queue(&pxmitpriv->bm_pending);
_rtw_init_queue(&pxmitpriv->free_xmit_queue);
pxmitpriv->pallocated_frame_buf = rtw_zvmalloc(NR_XMITFRAME * sizeof(struct xmit_frame) + 4);
if (pxmitpriv->pallocated_frame_buf == NULL){
pxmitpriv->pxmit_frame_buf =NULL;
RT_TRACE(_module_rtl871x_xmit_c_,_drv_err_,("alloc xmit_frame fail!\n"));
res= _FAIL;
goto exit;
}
pxmitpriv->pxmit_frame_buf = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pxmitpriv->pallocated_frame_buf), 4);
pxframe = (struct xmit_frame*) pxmitpriv->pxmit_frame_buf;
for (i = 0; i < NR_XMITFRAME; i++)
{
_rtw_init_listhead(&(pxframe->list));
pxframe->padapter = padapter;
pxframe->frame_tag = NULL_FRAMETAG;
pxframe->pkt = NULL;
pxframe->buf_addr = NULL;
pxframe->pxmitbuf = NULL;
rtw_list_insert_tail(&(pxframe->list), &(pxmitpriv->free_xmit_queue.queue));
pxframe++;
}
pxmitpriv->free_xmitframe_cnt = NR_XMITFRAME;
pxmitpriv->frag_len = MAX_FRAG_THRESHOLD;
_rtw_init_queue(&pxmitpriv->free_xmitbuf_queue);
_rtw_init_queue(&pxmitpriv->pending_xmitbuf_queue);
pxmitpriv->pallocated_xmitbuf = rtw_zvmalloc(NR_XMITBUFF * sizeof(struct xmit_buf) + 4);
if (pxmitpriv->pallocated_xmitbuf == NULL){
RT_TRACE(_module_rtl871x_xmit_c_,_drv_err_,("alloc xmit_buf fail!\n"));
res= _FAIL;
goto exit;
}
pxmitpriv->pxmitbuf = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pxmitpriv->pallocated_xmitbuf), 4);
pxmitbuf = (struct xmit_buf*)pxmitpriv->pxmitbuf;
for (i = 0; i < NR_XMITBUFF; i++)
{
_rtw_init_listhead(&pxmitbuf->list);
pxmitbuf->priv_data = NULL;
pxmitbuf->padapter = padapter;
pxmitbuf->buf_tag = XMITBUF_DATA;
if((res=rtw_os_xmit_resource_alloc(padapter, pxmitbuf,(MAX_XMITBUF_SZ + XMITBUF_ALIGN_SZ), _TRUE)) == _FAIL) {
rtw_msleep_os(10);
res = rtw_os_xmit_resource_alloc(padapter, pxmitbuf,(MAX_XMITBUF_SZ + XMITBUF_ALIGN_SZ), _TRUE);
if (res == _FAIL) {
goto exit;
}
}
#if defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
pxmitbuf->phead = pxmitbuf->pbuf;
pxmitbuf->pend = pxmitbuf->pbuf + MAX_XMITBUF_SZ;
pxmitbuf->len = 0;
pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead;
#endif
pxmitbuf->flags = XMIT_VO_QUEUE;
rtw_list_insert_tail(&pxmitbuf->list, &(pxmitpriv->free_xmitbuf_queue.queue));
#ifdef DBG_XMIT_BUF
pxmitbuf->no=i;
#endif
pxmitbuf++;
}
pxmitpriv->free_xmitbuf_cnt = NR_XMITBUFF;
_rtw_init_queue(&pxmitpriv->free_xframe_ext_queue);
pxmitpriv->xframe_ext_alloc_addr = rtw_zvmalloc(num_xmit_extbuf * sizeof(struct xmit_frame) + 4);
if (pxmitpriv->xframe_ext_alloc_addr == NULL){
pxmitpriv->xframe_ext = NULL;
RT_TRACE(_module_rtl871x_xmit_c_,_drv_err_,("alloc xframe_ext fail!\n"));
res= _FAIL;
goto exit;
}
pxmitpriv->xframe_ext = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pxmitpriv->xframe_ext_alloc_addr), 4);
pxframe = (struct xmit_frame*)pxmitpriv->xframe_ext;
for (i = 0; i < num_xmit_extbuf; i++) {
_rtw_init_listhead(&(pxframe->list));
pxframe->padapter = padapter;
pxframe->frame_tag = NULL_FRAMETAG;
pxframe->pkt = NULL;
pxframe->buf_addr = NULL;
pxframe->pxmitbuf = NULL;
pxframe->ext_tag = 1;
rtw_list_insert_tail(&(pxframe->list), &(pxmitpriv->free_xframe_ext_queue.queue));
pxframe++;
}
pxmitpriv->free_xframe_ext_cnt = num_xmit_extbuf;
_rtw_init_queue(&pxmitpriv->free_xmit_extbuf_queue);
pxmitpriv->pallocated_xmit_extbuf = rtw_zvmalloc(num_xmit_extbuf * sizeof(struct xmit_buf) + 4);
if (pxmitpriv->pallocated_xmit_extbuf == NULL){
RT_TRACE(_module_rtl871x_xmit_c_,_drv_err_,("alloc xmit_extbuf fail!\n"));
res= _FAIL;
goto exit;
}
pxmitpriv->pxmit_extbuf = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pxmitpriv->pallocated_xmit_extbuf), 4);
pxmitbuf = (struct xmit_buf*)pxmitpriv->pxmit_extbuf;
for (i = 0; i < num_xmit_extbuf; i++)
{
_rtw_init_listhead(&pxmitbuf->list);
pxmitbuf->priv_data = NULL;
pxmitbuf->padapter = padapter;
pxmitbuf->buf_tag = XMITBUF_MGNT;
if((res=rtw_os_xmit_resource_alloc(padapter, pxmitbuf,max_xmit_extbuf_size + XMITBUF_ALIGN_SZ, _TRUE)) == _FAIL) {
res= _FAIL;
goto exit;
}
#if defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
pxmitbuf->phead = pxmitbuf->pbuf;
pxmitbuf->pend = pxmitbuf->pbuf + max_xmit_extbuf_size;
pxmitbuf->len = 0;
pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead;
#endif
rtw_list_insert_tail(&pxmitbuf->list, &(pxmitpriv->free_xmit_extbuf_queue.queue));
#ifdef DBG_XMIT_BUF_EXT
pxmitbuf->no=i;
#endif
pxmitbuf++;
}
pxmitpriv->free_xmit_extbuf_cnt = num_xmit_extbuf;
pxmitbuf = &pxmitpriv->pcmd_xmitbuf;
if (pxmitbuf) {
_rtw_init_listhead(&pxmitbuf->list);
pxmitbuf->priv_data = NULL;
pxmitbuf->padapter = padapter;
pxmitbuf->buf_tag = XMITBUF_CMD;
if((res=rtw_os_xmit_resource_alloc(padapter, pxmitbuf, MAX_CMDBUF_SZ+XMITBUF_ALIGN_SZ, _TRUE)) == _FAIL) {
res= _FAIL;
goto exit;
}
#if defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
pxmitbuf->phead = pxmitbuf->pbuf;
pxmitbuf->pend = pxmitbuf->pbuf + MAX_CMDBUF_SZ;
pxmitbuf->len = 0;
pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead;
#endif
pxmitbuf->alloc_sz = MAX_CMDBUF_SZ+XMITBUF_ALIGN_SZ;
}
rtw_alloc_hwxmits(padapter);
rtw_init_hwxmits(pxmitpriv->hwxmits, pxmitpriv->hwxmit_entry);
for (i = 0; i < 4; i ++)
{
pxmitpriv->wmm_para_seq[i] = i;
}
#ifdef CONFIG_USB_HCI
pxmitpriv->txirp_cnt=1;
_rtw_init_sema(&(pxmitpriv->tx_retevt), 0);
pxmitpriv->beq_cnt = 0;
pxmitpriv->bkq_cnt = 0;
pxmitpriv->viq_cnt = 0;
pxmitpriv->voq_cnt = 0;
#endif
#ifdef CONFIG_XMIT_ACK
pxmitpriv->ack_tx = _FALSE;
_rtw_mutex_init(&pxmitpriv->ack_tx_mutex);
rtw_sctx_init(&pxmitpriv->ack_tx_ops, 0);
#endif
rtw_hal_init_xmit_priv(padapter);
exit:
_func_exit_;
return res;
} |
static void _init_txservq(struct tx_servq *ptxservq);
void _rtw_init_sta_xmit_priv(struct sta_xmit_priv *psta_xmitpriv);
void rtw_mfree_xmit_priv_lock (struct xmit_priv *pxmitpriv);
void _rtw_free_xmit_priv (struct xmit_priv *pxmitpriv);
u8 query_ra_short_GI(struct sta_info *psta);
static void update_attrib_vcs_info(_adapter *padapter, struct xmit_frame *pxmitframe);
static void update_attrib_phy_info(_adapter *padapter, struct pkt_attrib *pattrib, struct sta_info *psta);
static s32 update_attrib_sec_info(_adapter *padapter, struct pkt_attrib *pattrib, struct sta_info *psta);
u8 qos_acm(u8 acm_mask, u8 priority);
static void set_qos(struct pkt_file *ppktfile, struct pkt_attrib *pattrib);
void rtw_check_tdls_established(_adapter *padapter, struct pkt_attrib *pattrib);
s32 update_tdls_attrib(_adapter *padapter, struct pkt_attrib *pattrib);
static s32 update_attrib(_adapter *padapter, _pkt *pkt, struct pkt_attrib *pattrib);
static s32 xmitframe_addmic(_adapter *padapter, struct xmit_frame *pxmitframe);
static s32 xmitframe_swencrypt(_adapter *padapter, struct xmit_frame *pxmitframe);
s32 rtw_make_wlanhdr (_adapter *padapter , u8 *hdr, struct pkt_attrib *pattrib);
s32 rtw_txframes_pending(_adapter *padapter);
s32 rtw_txframes_sta_ac_pending(_adapter *padapter, struct pkt_attrib *pattrib);
int rtw_build_tdls_ies(_adapter * padapter, struct xmit_frame * pxmitframe, u8 *pframe, struct tdls_txmgmt *ptxmgmt);
s32 rtw_make_tdls_wlanhdr (_adapter *padapter , u8 *hdr, struct pkt_attrib *pattrib, struct tdls_txmgmt *ptxmgmt);
s32 rtw_xmit_tdls_coalesce(_adapter * padapter, struct xmit_frame * pxmitframe, struct tdls_txmgmt *ptxmgmt);
u32 rtw_calculate_wlan_pkt_size_by_attribue(struct pkt_attrib *pattrib);
s32 rtw_xmitframe_coalesce(_adapter *padapter, _pkt *pkt, struct xmit_frame *pxmitframe);
s32 rtw_mgmt_xmitframe_coalesce(_adapter *padapter, _pkt *pkt, struct xmit_frame *pxmitframe);
s32 rtw_put_snap(u8 *data, u16 h_proto);
void rtw_update_protection(_adapter *padapter, u8 *ie, uint ie_len);
void rtw_count_tx_stats(PADAPTER padapter, struct xmit_frame *pxmitframe, int sz);
struct xmit_buf *rtw_alloc_cmd_xmitbuf(struct xmit_priv *pxmitpriv);
s32 rtw_free_cmd_xmitbuf(struct xmit_priv *pxmitpriv);
struct xmit_frame *rtw_alloc_cmdxmitframe(struct xmit_priv *pxmitpriv);
struct xmit_buf *rtw_alloc_xmitbuf_ext(struct xmit_priv *pxmitpriv);
s32 rtw_free_xmitbuf_ext(struct xmit_priv *pxmitpriv, struct xmit_buf *pxmitbuf);
struct xmit_buf *rtw_alloc_xmitbuf(struct xmit_priv *pxmitpriv);
s32 rtw_free_xmitbuf(struct xmit_priv *pxmitpriv, struct xmit_buf *pxmitbuf);
void rtw_init_xmitframe(struct xmit_frame *pxframe);
struct xmit_frame *rtw_alloc_xmitframe(struct xmit_priv *pxmitpriv);
struct xmit_frame *rtw_alloc_xmitframe_ext(struct xmit_priv *pxmitpriv);
struct xmit_frame *rtw_alloc_xmitframe_once(struct xmit_priv *pxmitpriv);
s32 rtw_free_xmitframe(struct xmit_priv *pxmitpriv, struct xmit_frame *pxmitframe);
void rtw_free_xmitframe_queue(struct xmit_priv *pxmitpriv, _queue *pframequeue);
s32 rtw_xmitframe_enqueue(_adapter *padapter, struct xmit_frame *pxmitframe);
static struct xmit_frame *dequeue_one_xmitframe(struct xmit_priv *pxmitpriv, struct hw_xmit *phwxmit, struct tx_servq *ptxservq, _queue *pframe_queue);
struct xmit_frame* rtw_dequeue_xframe(struct xmit_priv *pxmitpriv, struct hw_xmit *phwxmit_i, sint entry);
struct tx_servq *rtw_get_sta_pending(_adapter *padapter, struct sta_info *psta, sint up, u8 *ac);
tx_servq *rtw_get_sta_pending
(_adapter *padapter, _queue **ppstapending, struct sta_info *psta, sint up);
s32 rtw_xmit_classifier(_adapter *padapter, struct xmit_frame *pxmitframe);
void rtw_alloc_hwxmits(_adapter *padapter);
void rtw_free_hwxmits(_adapter *padapter);
void rtw_init_hwxmits(struct hw_xmit *phwxmit, sint entry);
int rtw_br_client_tx(_adapter *padapter, struct sk_buff **pskb);
u32 rtw_get_ff_hwaddr(struct xmit_frame *pxmitframe);
static void do_queue_select(_adapter *padapter, struct pkt_attrib *pattrib);
s32 rtw_xmit(_adapter *padapter, _pkt **ppkt);
sint xmitframe_enqueue_for_tdls_sleeping_sta(_adapter *padapter, struct xmit_frame *pxmitframe);
sint xmitframe_enqueue_for_sleeping_sta(_adapter *padapter, struct xmit_frame *pxmitframe);
static void dequeue_xmitframes_to_sleeping_queue(_adapter *padapter, struct sta_info *psta, _queue *pframequeue);
void wakeup_sta_to_xmit(_adapter *padapter, struct sta_info *psta);
void xmit_delivery_enabled_frames(_adapter *padapter, struct sta_info *psta);
thread_return rtw_xmit_thread(thread_context context);
void rtw_sctx_init(struct submit_ctx *sctx, int timeout_ms);
int rtw_sctx_wait(struct submit_ctx *sctx, const char *msg);
bool rtw_sctx_chk_waring_status(int status);
void rtw_sctx_done_err(struct submit_ctx **sctx, int status);
void rtw_sctx_done(struct submit_ctx **sctx);
int rtw_ack_tx_polling(struct xmit_priv *pxmitpriv, u32 timeout_ms);
int rtw_ack_tx_wait(struct xmit_priv *pxmitpriv, u32 timeout_ms);
void rtw_ack_tx_done(struct xmit_priv *pxmitpriv, int status);
| a7bdb93b2d03f8db7211e8f88a15146b7465df38e9fdc0927e087bea708d11cf | 6,450 |
|
howard5888 | wine | wine-1.7.7/dlls/crypt32/tests/chain.c | checkChainPolicyStatus |
static void checkChainPolicyStatus(LPCSTR policy, HCERTCHAINENGINE engine,
const ChainPolicyCheck *check, LPCSTR testName, DWORD testIndex,
SYSTEMTIME *sysTime, PCERT_CHAIN_POLICY_PARA para)
{
PCCERT_CHAIN_CONTEXT chain = getChain(engine, &check->certs, 0, TRUE,
sysTime, check->todo, testIndex);
if (chain)
{
CERT_CHAIN_POLICY_STATUS policyStatus = { 0 };
BOOL ret = pCertVerifyCertificateChainPolicy(policy, chain, para,
&policyStatus);
if (check->todo & TODO_POLICY)
todo_wine ok(ret,
"%s[%d](%s): CertVerifyCertificateChainPolicy failed: %08x\n",
testName, testIndex,
IS_INTOID(policy) ? num_to_str(LOWORD(policy)) : policy,
GetLastError());
else
{
if (!ret && GetLastError() == ERROR_FILE_NOT_FOUND)
{
skip("%s[%d]: missing policy %s, skipping test\n",
testName, testIndex,
IS_INTOID(policy) ? num_to_str(LOWORD(policy)) : policy);
pCertFreeCertificateChain(chain);
return;
}
ok(ret, "%s[%d](%s): CertVerifyCertificateChainPolicy failed: %08x\n",
testName, testIndex,
IS_INTOID(policy) ? num_to_str(LOWORD(policy)) : policy,
GetLastError());
}
if (ret)
{
if (check->todo & TODO_ERROR)
todo_wine ok(policyStatus.dwError == check->status.dwError ||
broken(policyStatus.dwError == CERT_TRUST_NO_ERROR) ||
(check->brokenStatus && broken(policyStatus.dwError ==
check->brokenStatus->dwError)),
"%s[%d](%s): expected %08x, got %08x\n",
testName, testIndex,
IS_INTOID(policy) ? num_to_str(LOWORD(policy)) : policy,
check->status.dwError, policyStatus.dwError);
else
ok(policyStatus.dwError == check->status.dwError ||
broken(policyStatus.dwError == CERT_TRUST_NO_ERROR) ||
(check->brokenStatus && broken(policyStatus.dwError ==
check->brokenStatus->dwError)),
"%s[%d](%s): expected %08x, got %08x\n",
testName, testIndex,
IS_INTOID(policy) ? num_to_str(LOWORD(policy)) : policy,
check->status.dwError, policyStatus.dwError);
if (policyStatus.dwError != check->status.dwError)
{
skip("%s[%d](%s): error %08x doesn't match expected %08x, not checking indexes\n",
testName, testIndex,
IS_INTOID(policy) ? num_to_str(LOWORD(policy)) : policy,
policyStatus.dwError, check->status.dwError);
pCertFreeCertificateChain(chain);
return;
}
if (check->todo & TODO_CHAINS)
todo_wine ok(policyStatus.lChainIndex ==
check->status.lChainIndex ||
(check->brokenStatus && broken(policyStatus.lChainIndex ==
check->brokenStatus->lChainIndex)),
"%s[%d](%s): expected %d, got %d\n",
testName, testIndex,
IS_INTOID(policy) ? num_to_str(LOWORD(policy)) : policy,
check->status.lChainIndex, policyStatus.lChainIndex);
else
ok(policyStatus.lChainIndex == check->status.lChainIndex ||
(check->brokenStatus && broken(policyStatus.lChainIndex ==
check->brokenStatus->lChainIndex)),
"%s[%d](%s): expected %d, got %d\n",
testName, testIndex,
IS_INTOID(policy) ? num_to_str(LOWORD(policy)) : policy,
check->status.lChainIndex, policyStatus.lChainIndex);
if (check->todo & TODO_ELEMENTS)
todo_wine ok(policyStatus.lElementIndex ==
check->status.lElementIndex ||
(check->brokenStatus && broken(policyStatus.lElementIndex ==
check->brokenStatus->lElementIndex)),
"%s[%d](%s): expected %d, got %d\n",
testName, testIndex,
IS_INTOID(policy) ? num_to_str(LOWORD(policy)) : policy,
check->status.lElementIndex, policyStatus.lElementIndex);
else
ok(policyStatus.lElementIndex == check->status.lElementIndex ||
(check->brokenStatus && broken(policyStatus.lElementIndex ==
check->brokenStatus->lElementIndex)),
testName, testIndex,
"%s[%d](%s): expected %d, got %d\n",
IS_INTOID(policy) ? num_to_str(LOWORD(policy)) : policy,
check->status.lElementIndex, policyStatus.lElementIndex);
}
pCertFreeCertificateChain(chain);
}
} |
static void testCreateCertChainEngine(void);
static void _test_name_blob(unsigned line, CERT_NAME_BLOB *blob, const char *exdata);
static void testGetCertChain(void);
static void test_CERT_CHAIN_PARA_cbSize(void);
static const char *num_to_str(WORD num);
static void check_base_policy(void);
static void check_authenticode_policy(void);
static void check_ssl_policy(void);
static void testVerifyCertChainPolicy(void);
START_TEST(chain);
| 14f1ede93d4aa40dc1acb70783e8424149ca61807cc84f59fac16866e485c9a3 | 4,911 |
|
jeffegg | beaglebone | drivers/scsi/megaraid/megaraid_sas_fusion.c | *megasas_get_cmd_fusion |
struct megasas_cmd_fusion *megasas_get_cmd_fusion(struct megasas_instance
*instance)
{
unsigned long flags;
struct fusion_context *fusion =
(struct fusion_context *)instance->ctrl_context;
struct megasas_cmd_fusion *cmd = NULL;
spin_lock_irqsave(&fusion->cmd_pool_lock, flags);
if (!list_empty(&fusion->cmd_pool)) {
cmd = list_entry((&fusion->cmd_pool)->next,
struct megasas_cmd_fusion, list);
list_del_init(&cmd->list);
} else {
printk(KERN_ERR "megasas: Command pool (fusion) empty!\n");
}
spin_unlock_irqrestore(&fusion->cmd_pool_lock, flags);
return cmd;
} |
static int megasas_create_frame_pool_fusion(struct megasas_instance *instance);
irqreturn_t megasas_isr_fusion(int irq, void *devp);
int megasas_wait_for_outstanding_fusion(struct megasas_instance *instance);
void megasas_reset_reply_desc(struct megasas_instance *instance);
int megasas_reset_fusion(struct Scsi_Host *shost);
void megasas_fusion_ocr_wq(struct work_struct *work);
| e97a247084799703a1888437d4f68d0b3f0ef82508e32e740aa0e5765c5fcdcf | 614 |
|
goncalor | C-utils | inetutils.c | atoh |
unsigned long atoh(char *ascii_address)
{
unsigned long IP;
struct in_addr address;
if(inet_aton(ascii_address, &address)==0)
{
errno = 1;
return 0;
}
IP = ntohl(address.s_addr);
return IP;
} |
unsigned long *getIPbyname(char *hostname);
| 546df611602af98ac36ab6417e536f03d299c01578c95f6f709b68d45dd5d895 | 206 |
|
BPI-SINOVOIP | BPI-Mainline-kernel | drivers/rtc/rtc-rx4581.c | rx4581_get_datetime |
static int rx4581_get_datetime(struct device *dev, struct rtc_time *tm)
{
struct spi_device *spi = to_spi_device(dev);
unsigned char date[7];
unsigned char data;
int err;
err = rx4581_get_reg(dev, RX4581_REG_FLAG, &data);
if (err != 0) {
dev_err(dev, "Unable to read device flags\n");
return -EIO;
}
do {
if (data & RX4581_FLAG_UF) {
err = rx4581_set_reg(dev,
RX4581_REG_FLAG, (data & ~RX4581_FLAG_UF));
if (err != 0) {
dev_err(dev, "Unable to write device "
"flags\n");
return -EIO;
}
}
date[0] = 0x80;
err = spi_write_then_read(spi, date, 1, date, 7);
if (err < 0) {
dev_err(dev, "Unable to read date\n");
return -EIO;
}
err = rx4581_get_reg(dev, RX4581_REG_FLAG, &data);
if (err != 0) {
dev_err(dev, "Unable to read device flags\n");
return -EIO;
}
} while (data & RX4581_FLAG_UF);
if (data & RX4581_FLAG_VLF)
dev_info(dev,
"low voltage detected, date/time is not reliable.\n");
dev_dbg(dev,
"%s: raw data is sec=%02x, min=%02x, hr=%02x, "
"wday=%02x, mday=%02x, mon=%02x, year=%02x\n",
__func__,
date[0], date[1], date[2], date[3], date[4], date[5], date[6]);
tm->tm_sec = bcd2bin(date[RX4581_REG_SC] & 0x7F);
tm->tm_min = bcd2bin(date[RX4581_REG_MN] & 0x7F);
tm->tm_hour = bcd2bin(date[RX4581_REG_HR] & 0x3F);
tm->tm_wday = ilog2(date[RX4581_REG_DW] & 0x7F);
tm->tm_mday = bcd2bin(date[RX4581_REG_DM] & 0x3F);
tm->tm_mon = bcd2bin(date[RX4581_REG_MO] & 0x1F) - 1;
tm->tm_year = bcd2bin(date[RX4581_REG_YR]);
if (tm->tm_year < 70)
tm->tm_year += 100;
dev_dbg(dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
"mday=%d, mon=%d, year=%d, wday=%d\n",
__func__,
tm->tm_sec, tm->tm_min, tm->tm_hour,
tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
return 0;
} |
static int rx4581_set_datetime(struct device *dev, struct rtc_time *tm);
static int rx4581_probe(struct spi_device *spi);
| 190be3b781ff4fe3407f4c44d2a06ed006baf6bf91ee6c413f4d5b9dccf5a5c6 | 1,794 |
|
michaelnau | workhorse-array | warray.c | void*
warray_sample |
const void*
warray_sample( const WArray* array )
{
assert( array );
assert( warray_nonEmpty( array ));
return warray_at( array, rand() % array->size );
} |
static int compareTwoElements( const void* element1, const void* element2 );
| 150eee11ea89a6058be791612ca559a85d86243ad2b63025c8f4a4424683d573 | 158 |
|
JianpingZeng | xcc | xcc/test/juliet/testcases/CWE190_Integer_Overflow/s06/CWE190_Integer_Overflow__char_rand_postinc_12.c | main |
int main(int argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMITGOOD
printLine("Calling good()...");
CWE190_Integer_Overflow__char_rand_postinc_12_good();
printLine("Finished good()");
#endif
#ifndef OMITBAD
printLine("Calling bad()...");
CWE190_Integer_Overflow__char_rand_postinc_12_bad();
printLine("Finished bad()");
#endif
return 0;
} |
void CWE190_Integer_Overflow__char_rand_postinc_12_bad();
static void goodB2G();
static void goodG2B();
void CWE190_Integer_Overflow__char_rand_postinc_12_good();
| 72962db41b29ef837c21a61ac0385ffaef297cae18d7e687a451fad39379ccca | 412 |
|
cbuscaron | thoughttreasure | src/repbasic.c | fclose | ||
stream == stdout || stream == stderr) {
return;
}
fclose(stream);
}
int StreamRea |
Bool UnsignedIntIsString(char *s);
int IntMin(int x, int y);
int IntMax(int x, int y);
int IntAbs(int x);
Bool IntIsChar(int c);
Bool IntIsString(char *s);
Bool IntIsSpecification(int specific, int general);
int IntParse(char *s, int len);
long LongAbs(long x);
Float FloatMin(Float x, Float y);
Float FloatMax(Float x, Float y);
Float FloatAbs(Float x);
Float FloatSign(Float x);
Float FloatRound(Float x, Float nearest);
Float FloatInt(Float x);
Float FloatAvgMinMax(Float x, Float y, Float xmin, Float ymin);
void FloatAvgInit(/* RESULTS */ Float *numer, Float *denom);
void FloatAvgAdd(Float x, /* RESULTS */ Float *numer, Float *denom);
Float FloatAvgResult(Float numer, Float denom, Float def);
Bool FloatIsChar(int c);
Bool FloatIsString(char *s);
Float FloatParse(char *s, int len);
void FloatRangeParse(char *s, Float *from, Float *to);
void RandomSeed(long seed);
Float RandomFloat0_1();
void RandomInit();
Float RandomFloatFromTo(Float from, Float to);
int Roll(int n);
int RandomIntFromTo(int from, int to);
Bool WithProbability(Float x);
Bool CharIsOpening(int c);
Bool CharClosing(int c);
Bool CharIsGreekLower(int c);
ol CharIsGreekUpper(int c);
harIsUpper(int c);
Lower(int c);
return(CharIsLower(c);
c);
f (Char_islower(c);
oLower(c);
- 'A');
);
lse return(c);
i++);
t = (HashTable *);
stdout);
U_SOURCE
snprintf(fn, (size_t);
*fn);
EN, DBGBAD, "%s %s", streq(mode, "r");
sprintf(fn, "%s/%s", TTRoot, filename);
OF == (c = getc(stream);
= getc(stream);
/* RESULTS */ char *answer);
{
fputs(question, stdout);
SUNOS
va_start(args);
utc(c, stream);
L);
ULL);
urn;
if (c == NEWLINE);
fputs(s, stream);
eturn;
while (*s);
m == NULL);
turn;
while (*s);
nt len;
len = strlen(word);
/* INPUT */ int maxlen, int sep1, int sep2, int sep3);
while ((c = StreamPeekc(stream);
i < spaces; i++);
________________________________________________\n",
stream);
*dc);
int sort_by_ts, int gen_pairs, Discourse *dc);
am;
if (NULL == (stream = StreamOpen(fn, "r");
ringArray *sa;
if (!(s = StringReadFile("In", 0);
atrec;
if (0 > stat(fn, &statrec);
i++);
dentLevel; i++);
ext);
C
return(DirectoryRead1(dirfn);
ntf(fn, "%s/%s", TTRoot, dirfn);
C
usleep(1000*(ms % 1000);
eep(ms / 1000);
ize);
r = realloc(ptr, size);
;
locMax);
e % QALIGN);
if ((!Starting);
);
(size > 32768);
f (buffer == NULL);
MemCheckFind(size_t size, char *typ);
CheckLen; i++);
mCheckFind(size, typ);
CheckFind(size, typ);
*stream);
MemCheck *mcheck;
if (MemCheckCounter++ > 25000);
);
Check *mcheck;
s = ((char *);
;
rce_malloc);
ail_malloc(size);
realloc(buffer, size);
"km");
ATNA);
(s, "mph");
LOATNA);
khz");
NA);
bs");
NA);
, "Kbyte");
(FloatParse(s, -1);
, "F");
eturn(NumberToObjClass((Float);
ar(*p);
urn(NumberToObjClass(FloatParse(s, -1);
StringTailEq(s, "frch");
||
IsDurStem(s);
*units1, *units2;
obj1 = NumberParse(tok1, stem);
;
if (streq(s0, "-Inf");
adTo(s+7, class, OBJNAMELEN, TREE_MICRO_SEP, TERM, TERM);
eok,
Bool *wascreated);
NULL, NULL, N("country");
eated;
if ((obj = TokenGetQuickobj(state, NULL, NULL, N("polity-state");
Bool wascreated;
if ((obj = TokenGetQuickobj(city, NULL, NULL, N("city");
ated;
if ((obj = TokenGetQuickobj(street, NULL, NULL, N("street");
eated;
if (lexentry[0] == TERM);
char *postalcode, char *city, char *state, char *country);
char *street, char *postalcode, char *city, char *state,
char *country);
char *streetnumber, char *street, char *postalcode,
char *city, char *state, char *country);
char *streetnumber, char *street, char *postalcode,
char *city, char *state, char *country);
s = text;
if (s[0] == TERM);
| a97a7f15163ee186baba1bd75635d0d5aeaaf658b908129144a220d1dd9d9cad | 101 |
|
119 | aircam-openwrt | GT-I5500_OpenSource_Kernel/kernel/arch/ia64/kernel/crash.c | int
kdump_init_notifier |
static int
kdump_init_notifier(struct notifier_block *self, unsigned long val, void *data)
{
struct ia64_mca_notify_die *nd;
struct die_args *args = data;
if (!kdump_on_init && !kdump_on_fatal_mca)
return NOTIFY_DONE;
if (!ia64_kimage) {
if (val == DIE_INIT_MONARCH_LEAVE)
ia64_mca_printk(KERN_NOTICE
"%s: kdump not configured\n",
__func__);
return NOTIFY_DONE;
}
if (val != DIE_INIT_MONARCH_LEAVE &&
val != DIE_INIT_SLAVE_LEAVE &&
val != DIE_INIT_MONARCH_PROCESS &&
val != DIE_MCA_RENDZVOUS_LEAVE &&
val != DIE_MCA_MONARCH_LEAVE)
return NOTIFY_DONE;
nd = (struct ia64_mca_notify_die *)args->err;
if ((val == DIE_INIT_MONARCH_LEAVE || val == DIE_INIT_SLAVE_LEAVE
|| val == DIE_INIT_MONARCH_PROCESS) && nd->sos->rv_rc == 1)
return NOTIFY_DONE;
switch (val) {
case DIE_INIT_MONARCH_PROCESS:
if (kdump_on_init) {
atomic_set(&kdump_in_progress, 1);
*(nd->monarch_cpu) = -1;
}
break;
case DIE_INIT_MONARCH_LEAVE:
if (kdump_on_init)
machine_kdump_on_init();
break;
case DIE_INIT_SLAVE_LEAVE:
if (atomic_read(&kdump_in_progress))
unw_init_running(kdump_cpu_freeze, NULL);
break;
case DIE_MCA_RENDZVOUS_LEAVE:
if (atomic_read(&kdump_in_progress))
unw_init_running(kdump_cpu_freeze, NULL);
break;
case DIE_MCA_MONARCH_LEAVE:
if (kdump_on_fatal_mca && !(*(nd->data))) {
atomic_set(&kdump_in_progress, 1);
*(nd->monarch_cpu) = -1;
machine_kdump_on_init();
}
break;
}
return NOTIFY_DONE;
} | 7a1598a4b38838ff3756f1efe19f0412d02bf683ea68e5e3716ac48402c3ec13 | 1,502 |
||
BASLQC | gPSP-mod | src/video.c | sceKernelDcacheWritebackRange | *vertices, *vertices_tmp;
sceKernelDcacheWritebackRange((void *)screen_texture, TEXTURE_SIZE);
sceGuStart(GU_DIRECT, display_list);
sceGuEnable(GU_BLEND);
sceGuTexMode(GU_PSM_4444, 0, 0, GU_FALSE);
vertices =
(struct Vertex *)sceGuGetMemory(2 * 31 * 2 * sizeof(struct Vertex));
if (vertices)
{
int i, x;
memset(vertices, 0, 2 * 31 * 2 * sizeof(struct Vertex));
vertices_tmp = vertices;
x = 24;
vertices_tmp[0].u = SPEEKER_SHADOW_X;
vertices_tmp[0].v = 0 + VOLICON_OFFSET;
vertices_tmp[0].x = 3 + x;
vertices_tmp[0].y = 3 + 230;
vertices_tmp[1].u = SPEEKER_SHADOW_X + 32;
vertices_tmp[1].v = 32 + VOLICON_OFFSET;
vertices_tmp[1].x = 3 + x + 32;
vertices_tmp[1].y = 3 + 230 + 32;
vertices_tmp += 2;
vertices_tmp[0].u = SPEEKER_X;
vertices_tmp[0].v = 0 + VOLICON_OFFSET;
vertices_tmp[0].x = x;
vertices_tmp[0].y = 230;
vertices_tmp[1].u = SPEEKER_X + 32;
vertices_tmp[1].v = 32 + VOLICON_OFFSET;
vertices_tmp[1].x = x + 32;
vertices_tmp[1].y = 230 + 32;
vertices_tmp += 2;
x = 64;
for (i = 0; i < volume; i++)
{
vertices_tmp[0].u = VOLUME_BAR_SHADOW_X;
vertices_tmp[0].v = 0 + VOLICON_OFFSET;
vertices_tmp[0].x = 3 + x;
vertices_tmp[0].y = 3 + 230;
vertices_tmp[1].u = VOLUME_BAR_SHADOW_X + 12;
vertices_tmp[1].v = 32 + VOLICON_OFFSET;
vertices_tmp[1].x = 3 + x + 12;
vertices_tmp[1].y = 3 + 230 + 32;
vertices_tmp += 2;
vertices_tmp[0].u = VOLUME_BAR_X;
vertices_tmp[0].v = 0 + VOLICON_OFFSET;
vertices_tmp[0].x = x;
vertices_tmp[0].y = 230;
vertices_tmp[1].u = VOLUME_BAR_X + 12;
vertices_tmp[1].v = 32 + VOLICON_OFFSET;
vertices_tmp[1].x = x + 12;
vertices_tmp[1].y = 230 + 32;
vertices_tmp += 2;
x += 12;
}
for (; i < 30; i++)
{
vertices_tmp[0].u = VOLUME_DOT_SHADOW_X;
vertices_tmp[0].v = 0 + VOLICON_OFFSET;
vertices_tmp[0].x = 3 + x;
vertices_tmp[0].y = 3 + 230;
vertices_tmp[1].u = VOLUME_DOT_SHADOW_X + 12;
vertices_tmp[1].v = 32 + VOLICON_OFFSET;
vertices_tmp[1].x = 3 + x + 12;
vertices_tmp[1].y = 3 + 230 + 32;
vertices_tmp += 2;
vertices_tmp[0].u = VOLUME_DOT_X;
vertices_tmp[0].v = 0 + VOLICON_OFFSET;
vertices_tmp[0].x = x;
vertices_tmp[0].y = 230;
vertices_tmp[1].u = VOLUME_DOT_X + 12;
vertices_tmp[1].v = 32 + VOLICON_OFFSET;
vertices_tmp[1].x = x + 12;
vertices_tmp[1].y = 230 + 32;
vertices_tmp += 2;
x += 12;
}
sceGuDrawArray(GU_SPRITES,
GU_TEXTURE_16BIT | GU_VERTEX_16BIT | GU_TRANSFORM_2D,
2 * 31 * 2, 0, vertices);
}
sceGuDisable(GU_BLEND);
sceGuTexMode(GU_PSM_5551, 0, 0, GU_FALSE);
sceGuFinish();
sceGuSync(0, GU_SYNC_FINISH);
}
/*------------------------------------------- |
static void order_obj(u32 video_mode);
static void order_layers(u32 layer_flags);
static void render_scanline_tile(u16 *scanline, u32 dispcnt);
static void render_scanline_bitmap(u16 *scanline, u32 dispcnt);
void update_scanline(void);
void init_video(void);
void video_term(void);
void flip_screen(u8 vsync);
static void generate_display_list(void);
static void bitbilt_gu(void);
static void bitbilt_sw(void);
void video_resolution_large(void);
void video_resolution_small(void);
static void set_gba_resolution(void);
void clear_screen(u16 color);
static void *vram_addr(void *frame, u32 x, u32 y);
u16 *copy_screen(void);
void blit_to_screen(u16 *src, u32 w, u32 h, u32 dest_x, u32 dest_y);
void draw_box_line(u32 x1, u32 y1, u32 x2, u32 y2, u16 color);
void draw_box_fill(u32 x1, u32 y1, u32 x2, u32 y2, u16 color);
void print_string(char *str, u32 fg_color, u32 bg_color, u32 x, u32 y);
e_icon(void);
x03050210);
| ae6d0f201a59ae72d14ff59c121fff47858bb0b8ffc2c95bc386f8b266d6594f | 2,943 |
|
DutchDanny | SensationXL-ICS | drivers/md/dm-table.c | *dm_table_get_md |
struct mapped_device *dm_table_get_md(struct dm_table *t)
{
return t->md;
} |
static unsigned int int_log(unsigned int n, unsigned int base);
static inline unsigned int get_child(unsigned int n, unsigned int k);
static sector_t high(struct dm_table *t, unsigned int l, unsigned int n);
static int setup_btree_index(unsigned int l, struct dm_table *t);
void *dm_vcalloc(unsigned long nmemb, unsigned long elem_size);
static int alloc_targets(struct dm_table *t, unsigned int num);
static void free_devices(struct list_head *devices);
void dm_table_destroy(struct dm_table *t);
void dm_table_get(struct dm_table *t);
void dm_table_put(struct dm_table *t);
static inline int check_space(struct dm_table *t);
static struct dm_dev_internal *find_device(struct list_head *l, dev_t dev);
static void close_dev(struct dm_dev_internal *d, struct mapped_device *md);
void dm_put_device(struct dm_target *ti, struct dm_dev *d);
static int adjoin(struct dm_table *table, struct dm_target *ti);
static char **realloc_argv(unsigned *array_size, char **old_argv);
int dm_split_args(int *argc, char ***argvp, char *input);
static int dm_table_set_type(struct dm_table *t);
unsigned dm_table_get_type(struct dm_table *t);
bool dm_table_request_based(struct dm_table *t);
int dm_table_alloc_md_mempools(struct dm_table *t);
void dm_table_free_md_mempools(struct dm_table *t);
struct dm_md_mempools *dm_table_get_md_mempools(struct dm_table *t);
static int setup_indexes(struct dm_table *t);
static int dm_table_build_index(struct dm_table *t);
static int dm_table_prealloc_integrity(struct dm_table *t, struct mapped_device *md);
int dm_table_complete(struct dm_table *t);
void dm_table_event(struct dm_table *t);
sector_t dm_table_get_size(struct dm_table *t);
struct dm_target *dm_table_get_target(struct dm_table *t, unsigned int index);
struct dm_target *dm_table_find_target(struct dm_table *t, sector_t sector);
static void dm_table_set_integrity(struct dm_table *t);
unsigned int dm_table_get_num_targets(struct dm_table *t);
struct list_head *dm_table_get_devices(struct dm_table *t);
fmode_t dm_table_get_mode(struct dm_table *t);
static void suspend_targets(struct dm_table *t, unsigned postsuspend);
void dm_table_presuspend_targets(struct dm_table *t);
void dm_table_postsuspend_targets(struct dm_table *t);
int dm_table_resume_targets(struct dm_table *t);
void dm_table_add_target_callbacks(struct dm_table *t, struct dm_target_callbacks *cb);
int dm_table_any_congested(struct dm_table *t, int bdi_bits);
int dm_table_any_busy_target(struct dm_table *t);
bool dm_table_supports_discards(struct dm_table *t);
| ccc86d8e71e900639b77ca7f6301bfa990f3bff6ceba48fa5f03b4a3b9071cd5 | 77 |
|
google | nsync | testing/cv_mu_timeout_stress_test.c | count_is0mod4 |
static int count_is0mod4 (const void *v) {
const cv_stress_data *s = (const cv_stress_data *) v;
nsync_mu_rassert_held (&s->mu);
return ((s->count & 3) == 0);
} |
static void cv_stress_inc_loop (cv_stress_data *s, uintmax_t count_imod4);
static void cv_stress_reader_loop (cv_stress_data *s, uintmax_t count_imod4);
static int count_is1mod4 (const void *v);
static int count_is2mod4 (const void *v);
static int count_is3mod4 (const void *v);
static int count_is0mod4or_refs_is0 (const void *v);
static int count_is1mod4or_refs_is0 (const void *v);
static int count_is2mod4or_refs_is0 (const void *v);
static int count_is3mod4or_refs_is0 (const void *v);
static void test_cv_timeout_stress (testing t);
static void test_mu_timeout_stress (testing t);
static void test_mu_cv_timeout_stress (testing t);
int main (int argc, char *argv[]);
| 7b5608f37f3f04795a2d0804c79a205814a916fac4496792687ea8ad40f90e85 | 164 |
|
satishagrwal | Assignment | freeswitch_git/switch_core_media.c |
SWITCH_DECLARE |
SWITCH_DECLARE(void) switch_media_handle_set_media_flag(switch_media_handle_t *smh, switch_core_media_flag_t flag)
{
switch_assert(smh);
smh->media_flags[flag] = 1;
} |
SWITCH_DECLARE(switch_rtp_crypto_key_type_t);
SWITCH_DECLARE(const char *);
SWITCH_DECLARE(int);
static inline switch_media_flow_t sdp_media_flow(unsigned in);
static int get_channels(const char *name, int dft);
static void _switch_core_media_pass_zrtp_hash2(switch_core_session_t *aleg_session, switch_core_session_t *bleg_session, switch_media_type_t type);
SWITCH_DECLARE(uint32_t);
SWITCH_DECLARE(void);
SWITCH_DECLARE(void);
SWITCH_DECLARE(const char *);
static void switch_core_media_find_zrtp_hash(switch_core_session_t *session, sdp_session_t *sdp);
static switch_t38_options_t * switch_core_media_process_udptl(switch_core_session_t *session, sdp_session_t *sdp, sdp_media_t *m);
SWITCH_DECLARE(switch_status_t);
SWITCH_DECLARE(switch_status_t);
SWITCH_DECLARE(switch_t38_options_t *);
SWITCH_DECLARE(switch_status_t);
SWITCH_DECLARE(switch_status_t);
SWITCH_DECLARE(payload_map_t *);
SWITCH_DECLARE(const char *);
SWITCH_DECLARE(void);
SWITCH_DECLARE(const char *);
SWITCH_DECLARE(void);
switch_status_t switch_core_media_add_crypto(switch_secure_settings_t *ssec, const char *key_str, switch_rtp_crypto_direction_t direction);
SWITCH_DECLARE(void);
static void switch_core_session_get_recovery_crypto_key(switch_core_session_t *session, switch_media_type_t type);
static void switch_core_session_apply_crypto(switch_core_session_t *session, switch_media_type_t type);
static void switch_core_session_parse_crypto_prefs(switch_core_session_t *session);
SWITCH_DECLARE(int);
SWITCH_DECLARE(void);
static void set_stats(switch_core_session_t *session, switch_media_type_t type, const char *prefix);
SWITCH_DECLARE(void);
SWITCH_DECLARE(void);
SWITCH_DECLARE(void);
SWITCH_DECLARE(switch_status_t);
SWITCH_DECLARE(void);
SWITCH_DECLARE(void);
SWITCH_DECLARE(int32_t);
SWITCH_DECLARE(switch_media_flow_t);
SWITCH_DECLARE(switch_status_t);
SWITCH_DECLARE(switch_media_handle_t *);
SWITCH_DECLARE(switch_status_t);
SWITCH_DECLARE(switch_core_media_params_t *);
SWITCH_DECLARE(void);
static void check_jb(switch_core_session_t *session, const char *input, int32_t jb_msec, int32_t maxlen, switch_bool_t silent);
static void check_jb_sync(switch_core_session_t *session);
SWITCH_DECLARE(switch_status_t);
SWITCH_DECLARE(switch_status_t);
SWITCH_DECLARE(switch_status_t);
static int get_rtt_red_seq(int want_seq, void *data, switch_size_t datalen, int seq, switch_payload_t *new_payload, void *new_data, uint32_t *new_datalen);
static void *get_rtt_payload(void *data, switch_size_t datalen, switch_payload_t *new_payload, uint32_t *new_datalen, int *red_level);
SWITCH_DECLARE(switch_status_t);
WITCH_DECLARE(switch_status_t);
WITCH_DECLARE(void);
WITCH_DECLARE(switch_status_t);
tatic void switch_core_session_parse_codec_settings(switch_core_session_t *session, switch_media_type_t type);
WITCH_DECLARE(switch_status_t);
WITCH_DECLARE(switch_status_t);
tatic void clear_ice(switch_core_session_t *session, switch_media_type_t type);
WITCH_DECLARE(void);
WITCH_DECLARE(void);
WITCH_DECLARE(void);
WITCH_DECLARE(switch_status_t);
WITCH_DECLARE(void);
tatic void generate_local_fingerprint(switch_media_handle_t *smh, switch_media_type_t type);
tatic int dtls_ok(switch_core_session_t *session);
WITCH_DECLARE(switch_call_direction_t);
tatic switch_status_t ip_choose_family(switch_media_handle_t *smh, const char *ip);
tatic switch_bool_t ip_possible(switch_media_handle_t *smh, const char *ip);
tatic switch_status_t check_ice(switch_media_handle_t *smh, switch_media_type_t type, sdp_session_t *sdp, sdp_media_t *m);
WITCH_DECLARE(void);
tatic void greedy_sort(switch_media_handle_t *smh, struct matches *matches, int m_idx, const switch_codec_implementation_t **codec_array, int total_codecs);
tatic void clear_pmaps(switch_rtp_engine_t *engine);
tatic void restore_pmaps(switch_rtp_engine_t *engine);
WITCH_DECLARE(uint8_t);
WITCH_DECLARE(void);
WITCH_DECLARE(int);
WITCH_DECLARE(switch_file_handle_t *);
tatic void switch_core_session_write_blank_video(switch_core_session_t *session, uint32_t ms);
tatic void *SWITCH_THREAD_FUNC video_write_thread(switch_thread_t *thread, void *obj);
WITCH_DECLARE(switch_status_t);
WITCH_DECLARE(switch_status_t);
WITCH_DECLARE(switch_status_t);
nt next_cpu(void);
WITCH_DECLARE(void);
tatic switch_status_t perform_write(switch_core_session_t *session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id);
tatic void *SWITCH_THREAD_FUNC audio_write_thread(switch_thread_t *thread, void *obj);
WITCH_DECLARE(switch_status_t);
tatic void *SWITCH_THREAD_FUNC text_helper_thread(switch_thread_t *thread, void *obj);
WITCH_DECLARE(switch_status_t);
tatic void *SWITCH_THREAD_FUNC video_helper_thread(switch_thread_t *thread, void *obj);
WITCH_DECLARE(switch_status_t);
WITCH_DECLARE(void);
WITCH_DECLARE(int);
WITCH_DECLARE(void);
WITCH_DECLARE(switch_bool_t);
WITCH_DECLARE(void);
WITCH_DECLARE(switch_status_t);
WITCH_DECLARE(int);
WITCH_DECLARE(switch_status_t);
WITCH_DECLARE(void);
WITCH_DECLARE(switch_status_t);
WITCH_DECLARE(switch_status_t);
WITCH_DECLARE(void);
tatic void gen_ice(switch_core_session_t *session, switch_media_type_t type, const char *ip, switch_port_t port);
WITCH_DECLARE(void);
tatic void check_dtls_reinvite(switch_core_session_t *session, switch_rtp_engine_t *engine);
WITCH_DECLARE(switch_status_t);
tatic const char *get_media_profile_name(switch_core_session_t *session, int secure);
tatic char *get_setup(switch_rtp_engine_t *engine, switch_core_session_t *session, switch_sdp_type_t sdp_type);
WITCH_DECLARE(void);
witch_status_t switch_core_media_sdp_map(const char *r_sdp, switch_event_t **fmtp, switch_event_t **pt);
WITCH_DECLARE(void);
tatic void add_fb(char *buf, uint32_t buflen, int pt, int fir, int nack, int pli, int tmmbr);
WITCH_DECLARE(void);
WITCH_DECLARE(void);
WITCH_DECLARE(void);
WITCH_DECLARE(void);
WITCH_DECLARE(void);
WITCH_DECLARE(void);
tatic int check_engine(switch_rtp_engine_t *engine);
WITCH_DECLARE(switch_bool_t);
WITCH_DECLARE(switch_status_t);
WITCH_DECLARE(switch_status_t);
WITCH_DECLARE(switch_status_t);
WITCH_DECLARE(void);
WITCH_DECLARE(void);
WITCH_DECLARE(switch_status_t);
WITCH_DECLARE(switch_status_t);
WITCH_DECLARE(uint8_t);
WITCH_DECLARE(void);
WITCH_DECLARE(void);
WITCH_DECLARE(void);
WITCH_DECLARE(void);
WITCH_DECLARE(switch_rtp_stats_t *);
WITCH_DECLARE(switch_bool_t);
WITCH_DECLARE(switch_status_t);
WITCH_DECLARE(switch_jb_t *);
WITCH_DECLARE(void);
tatic void add_audio_codec(sdp_rtpmap_t *map, const switch_codec_implementation_t *imp, int ptime, char *buf, switch_size_t buflen);
tatic void switch_core_media_set_r_sdp_codec_string(switch_core_session_t *session, const char *codec_string, sdp_session_t *sdp, switch_sdp_type_t sdp_type);
WITCH_DECLARE(switch_status_t);
WITCH_DECLARE(void);
WITCH_DECLARE(void);
WITCH_DECLARE (void);
WITCH_DECLARE(void);
WITCH_DECLARE(void);
tatic int payload_number(const char *name);
tatic int find_pt(const char *sdp, const char *name);
WITCH_DECLARE(char *);
WITCH_DECLARE(char *);
WITCH_DECLARE(switch_timer_t *);
WITCH_DECLARE(switch_status_t);
WITCH_DECLARE(switch_status_t);
WITCH_DECLARE(switch_status_t);
WITCH_DECLARE(switch_bool_t);
WITCH_DECLARE(switch_status_t);
WITCH_DECLARE(void);
WITCH_DECLARE(switch_status_t);
WITCH_DECLARE(switch_status_t);
WITCH_DECLARE(switch_status_t);
WITCH_DECLARE(switch_status_t);
WITCH_DECLARE(switch_status_t);
WITCH_DECLARE(switch_status_t);
WITCH_DECLARE(switch_status_t);
WITCH_DECLARE(switch_status_t);
tatic void build_red_packet(switch_rtp_engine_t *t_engine);
WITCH_DECLARE(switch_status_t);
WITCH_DECLARE(switch_status_t);
WITCH_DECLARE(switch_status_t);
WITCH_DECLARE(switch_msrp_session_t *);
WITCH_DECLARE(switch_status_t);
| 7aa1ee693bca05d02cda14647e24cc6916f7becfb9797b96967d31f50f58b80b | 172 |
|
andyOsaft | 02_SourceCode | avrStudio4projects/imu3000Test/mlcontrol.c | MLGetControlData |
tMLError MLGetControlData(int *controlSignal, int *gridNum, int *gridChange)
{
int_fast8_t i=0;
if ( isCompatible( IMU_C_OPEN | IMU_C_START, IMU_C_OPEN_CALLED | IMU_C_START_CALLED) != ML_SUCCESS)
return ML_ERROR;
for (i=0; i<4; i++) {
controlSignal[i] = mlCtrlxData.controlInt[i];
gridNum[i] = mlCtrlxData.gridNum[i];
gridChange[i] = mlCtrlxData.gridChange[i];
}
return ML_SUCCESS;
} |
tMLError MLSetControlSensitivity(unsigned short controlSignal, int sensitivity);
tMLError MLSetControlFunc(unsigned short function);
tMLError MLGetControlSignal(unsigned short controlSignal, unsigned short reset, int *data);
tMLError MLGetGridNum(unsigned short controlSignal, unsigned short reset,int *data);
tMLError MLSetGridThresh(unsigned short controlSignal, int threshold);
tMLError MLSetGridMax(unsigned short controlSignal, int maximum);
tMLError MLSetGridCallback(GridCallbackPtr func);
tMLError MLSetControlSignals(unsigned short controlSignals);
tMLError MLSetControlData(unsigned short controlSignal, unsigned short parameterArray, unsigned short parameterAxis);
| 43978387e6bde8f0e13b685e4540275d14dab674bd88394d9f0782fc39c7a986 | 447 |
|
freedesktop-unofficial-mirror | twin | twin_demos/twin_clock.c | void
twin_clock_hand | static void
twin_clock_hand (twin_clock_t *clock,
twin_angle_t angle,
twin_fixed_t len,
twin_fixed_t fill_width,
twin_fixed_t out_width,
twin_argb32_t fill_pixel,
twin_argb32_t out_pixel)
{
twin_path_t *stroke = twin_path_create ();
twin_path_t *pen = twin_path_create ();
twin_path_t *path = twin_path_create ();
twin_matrix_t m;
twin_clock_set_transform (clock, stroke);
twin_path_rotate (stroke, angle);
twin_path_move (stroke, D(0), D(0));
twin_path_draw (stroke, len, D(0));
m = twin_path_current_matrix (stroke);
m.m[2][0] = 0;
m.m[2][1] = 0;
twin_path_set_matrix (pen, m);
twin_path_set_matrix (path, m);
twin_path_circle (pen, 0, 0, fill_width);
twin_path_convolve (path, stroke, pen);
twin_paint_path (_twin_clock_pixmap(clock), fill_pixel, path);
twin_paint_stroke (_twin_clock_pixmap(clock), out_pixel, path, out_width);
twin_path_destroy (path);
twin_path_destroy (pen);
twin_path_destroy (stroke);
}
| static twin_angle_t
twin_clock_minute_angle (int min);
static void
_twin_clock_face (twin_clock_t *clock);
static twin_time_t
_twin_clock_interval (void);
void
_twin_clock_paint (twin_clock_t *clock);
static twin_time_t
_twin_clock_timeout (twin_time_t now, void *closure);
twin_dispatch_result_t
_twin_clock_dispatch (twin_widget_t *widget, twin_event_t *event);
twin_clock_t *
twin_clock_create (twin_box_t *parent);
void
twin_clock_start (twin_screen_t *screen, const char *name, int x, int y, int w, int h);
| 4a677e8a6bc2bf9b2590421357a8a818dc450ccc69cd928044dae9f1d1166aba | 1,037 |
|
sgs3 | GT-I9305_Kernel | arch/arm/mach-exynos/secmem-allocdev.c | *get_drmbuf |
static inline void *get_drmbuf(unsigned int len)
{
if (!use_drm_buffer && len <= SZ_256K) {
use_drm_buffer = 1;
return drm_buffer;
}
return NULL;
} |
static inline void free_drmbuf(void);
static inline int alloc_drmbuf(void);
static inline int put_drmbuf(void *ptr);
static int secmem_mmap(struct file *file, struct vm_area_struct *vma);
static long secmem_ioctl(struct file *filp, unsigned int cmd, unsigned long arg);
void secmem_crypto_register(struct secmem_crypto_driver_ftn *ftn);
void secmem_crypto_deregister(void);
static int __init secmem_init(void);
static void __exit secmem_exit(void);
| 4b79481f95eb444ee2ef84311c825bc3dae99343f51362247cff7f2e51c4f7e8 | 156 |
|
newser | TitanSDK | platform/source/network/ssh/server/tt_ssh_server_conn.c | *tt_sshsvrconn_create |
tt_sshsvrconn_t *tt_sshsvrconn_create(IN tt_sshsvr_t *server)
{
tt_sshsvr_attr_t *attr;
tt_u32_t size;
tt_sshsvrconn_t *svrconn;
tt_result_t result;
tt_sshctx_attr_t ctx_attr;
tt_skt_attr_t skt_attr;
tt_skt_exit_t exit;
tt_u32_t __done = 0;
#define __SCO_MEM (1 << 0)
#define __SCO_RBUF (1 << 1)
#define __SCO_LINKED (1 << 2)
#define __SCO_CTX (1 << 3)
TT_ASSERT(server != NULL);
attr = &server->attr;
size = sizeof(tt_sshsvrconn_t);
size += sizeof(tt_sshch_t *) * server->attr.channel_per_conn;
svrconn = tt_malloc(size);
if (svrconn == NULL) {
TT_ERROR("no mem for server connection");
return NULL;
}
__done |= __SCO_MEM;
tt_memset(svrconn, 0, size);
svrconn->server = server;
svrconn->chmgr.itf = &tt_s_sshsvr_chmgr_itf;
result = tt_buf_create(&svrconn->recv_buf,
attr->conn_buf_init_size,
&attr->conn_buf_attr);
if (!TT_OK(result)) {
TT_ERROR("fail to create sshsvr conn recv buf");
goto scfail;
}
__done |= __SCO_RBUF;
svrconn->plaintext_len = 0;
tt_lnode_init(&svrconn->node);
svrconn->state = TT_SSHSVRST_VERXCHG;
ctx_attr.is_server = TT_TRUE;
result = tt_sshctx_create(&svrconn->ctx, &ctx_attr);
if (!TT_OK(result)) {
TT_ERROR("fail to create sshsvr conn context");
goto scfail;
}
__done |= __SCO_CTX;
svrconn->ch = TT_PTR_INC(tt_sshch_t *, svrconn, sizeof(tt_sshsvrconn_t));
svrconn->ch_num = server->attr.channel_per_conn;
svrconn->flag = 0;
svrconn->last_state = TT_SSHSVRST_NUM;
svrconn->by_event = TT_SSHSVREV_NUM;
tt_skt_attr_default(&skt_attr);
tt_skt_attr_set_nodelay(&skt_attr, TT_TRUE);
exit.on_destroy = __svrconn_on_destroy;
exit.cb_param = NULL;
result = tt_skt_accept_async(&server->skt,
&svrconn->skt,
&skt_attr,
&exit,
__svrconn_on_accept,
NULL);
if (!TT_OK(result)) {
TT_ERROR("fail to accept ssh server connection");
goto scfail;
}
tt_list_push_tail(&server->conn_list, &svrconn->node);
__done |= __SCO_LINKED;
return svrconn;
scfail:
if (__done & __SCO_LINKED) {
tt_list_remove(&svrconn->node);
}
if (__done & __SCO_CTX) {
tt_sshctx_destroy(&svrconn->ctx);
}
if (__done & __SCO_RBUF) {
tt_buf_destroy(&svrconn->recv_buf);
}
if (__done & __SCO_MEM) {
tt_free(svrconn);
}
return NULL;
} |
void tt_sshsvrconn_destroy(IN tt_sshsvrconn_t *svrconn, IN tt_bool_t immediate);
void tt_sshsvrconn_shutdown(IN tt_sshsvrconn_t *svrconn);
tt_result_t tt_sshsvrconn_recv(IN tt_sshsvrconn_t *svrconn);
void __svrconn_on_destroy(IN tt_skt_t *skt, IN void *cb_param);
tt_result_t __svrconn_parse(IN tt_sshsvrconn_t *svrconn, OUT tt_sshmsg_t **msg);
| 8281ea1c02b1dbf9c95f2d5f6194bb2cc651dfd7ee59dbbde0d867ffdd85e97b | 2,751 |
|
dirker | barebox | common/memory.c | mem_malloc_resource |
static int mem_malloc_resource(void)
{
request_sdram_region("malloc space",
malloc_start,
malloc_end - malloc_start + 1);
request_sdram_region("barebox",
(unsigned long)&_stext,
(unsigned long)&_etext -
(unsigned long)&_stext + 1);
request_sdram_region("bss",
(unsigned long)&__bss_start,
(unsigned long)&__bss_stop -
(unsigned long)&__bss_start + 1);
#ifdef STACK_BASE
request_sdram_region("stack", STACK_BASE, STACK_SIZE);
#endif
return 0;
} |
unsigned long mem_malloc_start(void);
unsigned long mem_malloc_end(void);
void mem_malloc_init(void *start, void *end);
static void *sbrk_no_zero(ptrdiff_t increment);
void *sbrk(ptrdiff_t increment);
int release_sdram_region(struct resource *res);
static int get_cells_len(struct fdt_header *fdt, char *nr_cells_name);
static void write_cell(u8 *addr, u64 val, int size);
static int of_memory_fixup(struct fdt_header *fdt);
static int of_register_memory_fixup(void);
| 1021253b9b443161fad3d1ecd9c24dc1e9770c4fdd4c0164d58ed60ee982433e | 476 |
|
DeforaOS | libDatabase | src/database.c | database_engine_statement_new |
DatabaseEngineStatement * database_engine_statement_new(Database * database,
char const * query)
{
return database->dplugin->statement_new(database->database, query);
} |
void database_delete(Database * database);
int64_t database_get_last_id(Database * database);
| 48624a9e7209c120dcc81f06c4df5e7a31fa363e9bd1d2ee1e472a046c6946ba | 172 |
|
AramisSA | brAthena | src/map/script.c | script_getnum | clear)
{
int idx = script_getnum(st, 2);
struct script_queue_iterator *it = NULL;
if (idx < 0 || idx >= VECTOR_LENGTH(script->hqi) || !VECTOR_INDEX(script->hqi, idx).valid) {
ShowWarning("buildin_qiclear: unknown queue iterator id %d\n",idx);
script_pushint(st, 0);
return false;
}
it = &VECTOR_INDEX(script->hqi, idx);
VECTOR_CLEAR(it->entries);
it->pos = 0;
it->valid = false;
script_pushint(st, 1);
return true;
}
/**
* pa | inline int GETVALUE(const unsigned char* buf, int i);
inline void SETVALUE(unsigned char* buf, int i, int n);
inline void script_string_buf_ensure(struct script_string_buf *buf, size_t ensure);
inline void script_string_buf_addb(struct script_string_buf *buf,uint8 b);
inline void script_string_buf_destroy(struct script_string_buf *buf);
har* script_op2name(int op);
void script_dump_stack(struct script_state* st);
ript_reportsrc(struct script_state *st);
ript_reportdata(struct script_data* data);
ript_reportfunc(struct script_state* st);
void disp_error_message2(const char *mes,const char *pos,int report);
sp_warning_message(const char *mes, const char *pos);
eck_event(struct script_state *st, const char *evt);
d int calc_hash(const char* p);
d int calc_hash_ci(const char* p);
har* script_get_str(int id);
ipt_search_str(const char* p);
ript_casecheck_clear_sub(struct casecheck_data *ccd);
ript_global_casecheck_clear(void);
ript_local_casecheck_clear(void);
har *script_casecheck_add_str_sub(struct casecheck_data *ccd, const char *p);
har *script_global_casecheck_add_str(const char *p);
har *script_local_casecheck_add_str(const char *p);
ipt_add_str(const char* p);
d_scriptb(int a);
d_scriptc(int a);
d_scripti(int a);
d_scriptl(int l);
t_label(int l,int pos, const char* script_pos);
har* script_skip_space(const char* p);
har* skip_word(const char* p);
_word(const char* p);
const char* parse_callfunc(const char* p, int require_paren, int is_custom);
rse_nextline(bool first, const char* p);
rse_variable_sub_push(int word, const char *p2);
har* parse_variable(const char* p);
_number(const char *p);
ipt_string_dup(char *str);
har* script_parse_subexpr(const char* p,int limit);
har* parse_expr(const char *p);
har* parse_line(const char* p);
har* parse_curly_close(const char* p);
har* parse_syntax(const char* p);
har* parse_syntax_close(const char *p);
har* parse_syntax_close_sub(const char* p,int* flag);
ript_get_constant(const char* name, int* value);
ript_set_constant(const char* name, int value, bool isparameter);
ript_set_constant2(const char *name, int value, bool isparameter);
ad_constdb(void);
ript_errorwarning_sub(StringBuf *buf, const char* src, const char* file, int start_line, const char* error_msg, const char* error_pos);
ript_error(const char* src, const char* file, int start_line, const char* error_msg, const char* error_pos);
ript_warning(const char* src, const char* file, int start_line, const char* error_msg, const char* error_pos);
script_code* parse_script(const char *src,const char *file,int line,int options, int *retval);
map_session_data *script_rid2sd(struct script_state *st);
map_session_data *script_id2sd(struct script_state *st, int account_id);
map_session_data *script_charid2sd(struct script_state *st, int char_id);
map_session_data *script_nick2sd(struct script_state *st, const char *name);
et_val_npcscope_str(struct script_state* st, struct reg_db *n, struct script_data* data);
et_val_instance_str(struct script_state* st, const char* name, struct script_data* data);
_val_npcscope_num(struct script_state* st, struct reg_db *n, struct script_data* data);
_val_instance_num(struct script_state* st, const char* name, struct script_data* data);
script_data *get_val(struct script_state* st, struct script_data* data);
et_val2(struct script_state* st, int64 uid, struct reg_db *ref);
ript_array_ensure_zero(struct script_state *st, struct map_session_data *sd, int64 uid, struct reg_db *ref);
d int script_array_size(struct script_state *st, struct map_session_data *sd, const char *name, struct reg_db *ref);
d int script_array_highest_key(struct script_state *st, struct map_session_data *sd, const char *name, struct reg_db *ref);
ipt_free_array_db(DBKey key, DBData *data, va_list ap);
ript_array_delete(struct reg_db *src, struct script_array *sa);
ript_array_remove_member(struct reg_db *src, struct script_array *sa, unsigned int idx);
ript_array_add_member(struct script_array *sa, unsigned int idx);
reg_db *script_array_src(struct script_state *st, struct map_session_data *sd, const char *name, struct reg_db *ref);
ript_array_update(struct reg_db *src, int64 num, bool empty);
t_reg_npcscope_str(struct script_state* st, struct reg_db *n, int64 num, const char* name, const char *str);
t_reg_npcscope_num(struct script_state* st, struct reg_db *n, int64 num, const char* name, int val);
t_reg_instance_str(struct script_state* st, int64 num, const char* name, const char *str);
t_reg_instance_num(struct script_state* st, int64 num, const char* name, int val);
_reg(struct script_state *st, struct map_session_data *sd, int64 num, const char *name, const void *value, struct reg_db *ref);
_var(struct map_session_data *sd, char *name, void *val);
td_sub(struct script_state *st, struct map_session_data *sd, const char *varname, int elem, void *value, struct reg_db *ref);
har* conv_str(struct script_state* st, struct script_data* data);
v_num(struct script_state* st, struct script_data* data);
ack_expand(struct script_stack* stack);
script_data* push_val(struct script_stack* stack, enum c_op type, int64 val, struct reg_db *ref);
script_data* push_str(struct script_stack* stack, enum c_op type, char* str);
script_data* push_retinfo(struct script_stack* stack, struct script_retinfo* ri, struct reg_db *ref);
script_data* push_copy(struct script_stack* stack, int pos);
p_stack(struct script_state* st, int start, int end);
ript_free_vars(struct DBMap* var_storage);
ript_free_code(struct script_code* code);
script_state* script_alloc_state(struct script_code* rootscript, int pos, int rid, int oid);
ript_free_state(struct script_state* st);
ript_add_pending_ref(struct script_state *st, struct reg_db *ref);
t_com(unsigned char *scriptbuf,int *pos);
_num(unsigned char *scriptbuf,int *pos);
_3(struct script_state* st, int op);
_2str(struct script_state* st, int op, const char* s1, const char* s2);
_2num(struct script_state* st, int op, int i1, int i2);
_2(struct script_state *st, int op);
_1(struct script_state* st, int op);
ript_check_buildin_argtype(struct script_state* st, int func);
_func(struct script_state *st);
n_script(struct script_code *rootscript, int pos, int rid, int oid);
ript_stop_instances(struct script_code *code);
_script_timer(int tid, int64 tick, int id, intptr_t data);
ript_detach_state(struct script_state* st, bool dequeue_event);
ript_attach_state(struct script_state* st);
n_script_main(struct script_state *st);
ipt_config_read(char *cfgName);
script_free_code_sub(DBKey key, DBData *data, va_list ap);
ript_run_autobonus(const char *autobonus, int id, int pos);
ript_add_autobonus(const char *autobonus);
ript_cleararray_pc(struct map_session_data* sd, const char* varname, void* value);
ript_setarray_pc(struct map_session_data* sd, const char* varname, uint32 idx, void* value, int* refcache);
ipt_reg_destroy(DBKey key, DBData *data, va_list ap);
ript_reg_destroy_single(struct map_session_data *sd, int64 reg, struct script_reg_state *data);
d int *script_array_cpy_list(struct script_array *sa);
ript_generic_ui_array_expand (unsigned int plus);
_final_script(void);
cript_add_language(const char *name);
ript_load_translations(void);
har * script_get_translation_file_name(const char *file);
ript_load_translation(const char *file, uint8 lang_id, uint32 *total);
ript_clear_translations(bool reload);
ipt_translation_db_destroyer(DBKey key, DBData *data, va_list ap);
ript_parser_clean_leftovers(void);
ipt_parse_cleanup_timer(int tid, int64 tick, int id, intptr_t data);
_init_script(bool minimal);
ipt_reload(void);
har *script_getfuncname(struct script_state *st);
(mes);
(next);
(close);
(close2);
u_countoptions(const char* str, int max_count, int* total);
(menu);
(select);
(prompt);
(goto);
(callfunc);
(callsub);
(getarg);
(return);
(rand);
(warp);
ldin_areawarp_sub(struct block_list *bl,va_list ap);
(areawarp);
ldin_areapercentheal_sub(struct block_list *bl, va_list ap);
(areapercentheal);
(warpchar);
(warpparty);
(warpguild);
(heal);
(itemheal);
(percentheal);
(jobchange);
(jobname);
(input);
(__setr);
(setarray);
(cleararray);
(copyarray);
(getarraysize);
ipt_array_index_cmp(const void *a, const void *b);
(deletearray);
(getelementofarray);
(setlook);
(changelook);
(cutin);
(viewpoint);
(countitem);
(countitem2);
(checkweight);
(checkweight2);
(getitem);
(getitem2);
(rentitem);
(getnameditem);
(grouprandomitem);
(makeitem);
ildin_delitem_delete(struct map_session_data* sd, int idx, int* amount, bool delete_items);
ildin_delitem_search(struct map_session_data* sd, struct item* it, bool exact_match);
(delitem);
(delitem2);
(enableitemuse);
(disableitemuse);
(readparam);
(getcharid);
(getnpcid);
(getpartyname);
(getpartymember);
(getpartyleader);
(getguildname);
(getguildmaster);
(getguildmasterid);
(getguildmember);
(strcharinfo);
(strnpcinfo);
(charid2rid);
(getequipid);
(getequipname);
(getbrokenid);
(getbrokencount);
(repair);
(repairall);
(getequipisequiped);
(getequipisenableref);
(getequipisidentify);
(getequiprefinerycnt);
(getequipweaponlv);
(getequippercentrefinery);
(successrefitem);
(failedrefitem);
(downrefitem);
(delequip);
(statusup);
(statusup2);
(bonus);
(autobonus);
(autobonus2);
(autobonus3);
(skill);
(addtoskill);
(guildskill);
(getskilllv);
(getgdskilllv);
(basicskillcheck);
(getgmlevel);
(setgroupid);
(getgroupid);
(end);
(checkoption);
(checkoption1);
(checkoption2);
(setoption);
(checkcart);
(setcart);
(checkfalcon);
(setfalcon);
(checkmount);
(setmount);
(checkwug);
(savepoint);
(gettimetick);
(gettime);
(gettimestr);
(openstorage);
(guildopenstorage);
(itemskill);
(produce);
(cooking);
(makepet);
(getexp);
(guildgetexp);
(guildchangegm);
(monster);
(getmobdrops);
(areamonster);
ldin_killmonster_sub_strip(struct block_list *bl, va_list ap);
ldin_killmonster_sub(struct block_list *bl, va_list ap);
(killmonster);
ldin_killmonsterall_sub_strip(struct block_list *bl,va_list ap);
ldin_killmonsterall_sub(struct block_list *bl,va_list ap);
(killmonsterall);
(clone);
(doevent);
(donpcevent);
(addtimer);
(deltimer);
(addtimercount);
(initnpctimer);
(startnpctimer);
(stopnpctimer);
(getnpctimer);
(setnpctimer);
(attachnpctimer);
(detachnpctimer);
(playerattached);
(announce);
ldin_announce_sub(struct block_list *bl, va_list ap);
(itemeffect);
(mapannounce);
(areaannounce);
(getusers);
(getusersname);
(getmapguildusers);
(getmapusers);
ldin_getareausers_sub(struct block_list *bl,va_list ap);
(getareausers);
ldin_getareadropitem_sub(struct block_list *bl, va_list ap);
(getareadropitem);
(enablenpc);
(disablenpc);
(hideoffnpc);
(hideonnpc);
(sc_start);
(sc_end);
(getscrate);
(getstatus);
(debugmes);
(catchpet);
(homunculus_evolution);
(homunculus_mutate);
(homunculus_morphembryo);
(homunculus_checkcall);
(homunculus_shuffle);
(eaclass);
(roclass);
(birthpet);
(resetlvl);
(resetstatus);
(resetskill);
(skillpointcount);
(changebase);
struct map_session_data *prepareChangeSex(struct script_state *st);
(opendressroom);
(closedressroom);
(changesex);
(changecharsex);
(globalmes);
(waitingroom);
(delwaitingroom);
(waitingroomkickall);
(enablewaitingroomevent);
(disablewaitingroomevent);
(getwaitingroomstate);
(warpwaitingpc);
ript_detach_rid(struct script_state* st);
(attachrid);
(detachrid);
(isloggedin);
(setmapflagnosave);
(getmapflag);
ipt_mapflag_pvp_sub(struct block_list *bl, va_list ap);
(setmapflag);
(removemapflag);
(pvpon);
ldin_pvpoff_sub(struct block_list *bl, va_list ap);
(pvpoff);
(gvgon);
(gvgoff);
(emotion);
ldin_maprespawnguildid_sub_pc(struct map_session_data* sd, va_list ap);
ldin_maprespawnguildid_sub_mob(struct block_list *bl, va_list ap);
(maprespawnguildid);
(agitstart);
(agitend);
(agitstart2);
(agitend2);
(agitcheck);
(agitcheck2);
(flagemblem);
(getcastlename);
(getcastledata);
(setcastledata);
(requestguildinfo);
(getequipcardcnt);
(successremovecards);
(failedremovecards);
(mapwarp);
ldin_mobcount_sub(struct block_list *bl, va_list ap);
(mobcount);
(marriage);
(wedding_effect);
(divorce);
(ispartneron);
(getpartnerid);
(getchildid);
(getmotherid);
(getfatherid);
(warppartner);
(strmobinfo);
(guardian);
(setwall);
(delwall);
(guardianinfo);
(getitemname);
(getitemslots);
(getiteminfo);
(setiteminfo);
(getequipcardid);
(petskillbonus);
(petloot);
(getinventorylist);
(getcartinventorylist);
(getskilllist);
(clearitem);
(disguise);
(undisguise);
(classchange);
(misceffect);
(playbgm);
ybgm_sub(struct block_list* bl,va_list ap);
ybgm_foreachpc_sub(struct map_session_data* sd, va_list args);
(playbgmall);
(soundeffect);
ndeffect_sub(struct block_list *bl, va_list ap);
(soundeffectall);
(petrecovery);
(petskillattack);
(petskillsupport);
(skilleffect);
(npcskilleffect);
(specialeffect);
(specialeffect2);
(nude);
(atcommand);
(dispbottom);
(recovery);
(getpetinfo);
(gethominfo);
(getmercinfo);
(checkequipedcard);
(__jump_zero);
(movenpc);
(message);
(npctalk);
(npcspeed);
(npcwalkto);
(npcstop);
(setnpcdistance);
(getnpcdir);
(setnpcdir);
(getnpcclass);
(getlook);
(getsavepoint);
(getmapxy);
(logmes);
(summon_rand);
(summon);
(isnight);
(isequippedcnt);
(isequipped);
(cardscnt);
(getrefine);
(night);
(day);
(unequip);
(equip);
(autoequip);
(equip2);
(setbattleflag);
(getbattleflag);
(getstrlen);
(charisalpha);
(charisupper);
(charislower);
(charat);
(setchar);
(insertchar);
(delchar);
(strtoupper);
(strtolower);
(substr);
(explode);
(implode);
(sprintf);
(sscanf);
(strpos);
(replacestr);
(countstr);
(setnpcdisplay);
(atoi);
(axtoi);
(strtol);
(compare);
(strcmp);
(log10);
(sqrt);
(pow);
(distance);
(min);
(max);
(md5);
(swap);
(setd);
ldin_query_sql_sub(struct script_state* st, Sql* handle);
(query_sql);
(query_logsql);
(escape_sql);
(getd);
(petstat);
(callshop);
(npcshopitem);
(npcshopadditem);
(npcshopdelitem);
(npcshopattach);
(setitemscript);
(addmonsterdrop);
(delmonsterdrop);
(getmonsterinfo);
(checkvending);
(checkchatting);
(checkidle);
(searchitem);
(rid2name);
(pcblockmove);
(pcfollow);
(pcstopfollow);
(getunittype);
(unitwalk);
(unitkill);
(unitwarp);
(unitattack);
(unitstop);
(unittalk);
(unitemote);
(unitskilluseid);
(unitskillusepos);
(sleep);
(sleep2);
(awake);
(getvariableofnpc);
(warpportal);
(openmail);
(openauction);
(checkcell);
(setcell);
(mercenary_create);
(mercenary_heal);
(mercenary_sc_start);
(mercenary_get_calls);
(mercenary_set_calls);
(mercenary_get_faith);
(mercenary_set_faith);
(readbook);
(questinfo);
(setquest);
(erasequest);
(completequest);
(changequest);
(questactive);
(questprogress);
(showevent);
(waitingroom2bg);
(waitingroom2bg_single);
(bg_team_setxy);
(bg_warp);
(bg_monster);
(bg_monster_set_team);
(bg_leave);
(bg_destroy);
(bg_getareausers);
(bg_updatescore);
(bg_get_data);
(instance_create);
(instance_destroy);
(instance_attachmap);
(instance_detachmap);
(instance_attach);
(instance_id);
(instance_set_timeout);
(instance_init);
(instance_announce);
(instance_npcname);
(has_instance);
ldin_instance_warpall_sub(struct block_list *bl, va_list ap);
(instance_warpall);
(instance_check_party);
(instance_check_guild);
(setfont);
ldin_mobuseskill_sub(struct block_list *bl, va_list ap);
(areamobuseskill);
(progressbar);
(pushpc);
(buyingstore);
(searchstores);
(showdigit);
(makerune);
(hascashmount);
(setcashmount);
(getargcount);
etcharmac);
tcharip);
_function);
eeloop);
t);
and);
sit);
ndatcmd);
bindatcmd);
eatcmd);
eckre);
trandgroupitem);
_cleanfloor_sub(struct block_list *bl, va_list ap);
eanmap);
cskill);
ntransform);
ipt_queue *script_hqueue_get(int idx);
_hqueue_create(void);
eue);
euesize);
t_hqueue_add(int idx, int var);
eueadd);
t_hqueue_remove(int idx, int var);
eueremove);
eueopt);
t_hqueue_del(int idx);
euedel);
t_hqueue_clear(int idx);
eueiterator);
get);
check);
ckageitem);
_create_team);
_join_team);
untbound);
eckbound);
_match_over);
stance_mapname);
stance_set_respawn);
enshop);
llitem);
opselling);
tcurrency);
adertype);
rchaseok);
opcount);
annelmes);
owscript);
rgeitem);
plicatenpc);
plicateremove);
tunitdata);
tunitdata);
stume);
;
re_match);
t_add_builtin(const struct script_function *buildin, bool override);
t_hp_add(char *name, char *args, bool (*func);
t_run_use_script(struct map_session_data *sd, struct item_data *data, int oid);
t_run_item_equip_script(struct map_session_data *sd, struct item_data *data, int oid);
t_run_item_unequip_script(struct map_session_data *sd, struct item_data *data, int oid);
t_parse_builtin(void);
t_label_add(int key, int pos);
t_hardcoded_constants(void);
hort script_mapindexname2id (struct script_state *st, const char* name);
t_defaults(void);
| f922a7227c599d1eb5d3f983d6c9e6d1a90f7109fb0b2e6ef7cc20b7e4f4a7b6 | 447 |
|
vyasgiridhar | Louder | glibsoundcloud/sc-api.c | void
sc_api_class_init |
static void
sc_api_class_init (ScApiClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->finalize = sc_api_finalize;
object_class->get_property = sc_api_get_property;
object_class->set_property = sc_api_set_property;
} | 551573d26e1036b066845fd12cd70d9aff851bd0a97371c01c88f5975cc384e9 | 266 |
||
thenewwazoo | markov-localizer | c99_fp/detector.c |
void
normalize_dist |
void
normalize_dist(
float posterior[const],
const size_t num_tooth_tips,
float normalized[]
)
{
#ifdef SOFTMAX
float sum = 0.0;
for (size_t i = 0; i < num_tooth_tips; i++)
sum += expf(posterior[i]);
for (size_t i = 0; i < num_tooth_tips; i++)
normalized[i] = expf(posterior[i]) / sum;
#else
float invsum = 0.0;
for (size_t i = 0; i < num_tooth_tips; i++)
invsum += posterior[i];
if (invsum == 0)
invsum = FLT_MAX;
invsum = 1.0 / invsum;
for (size_t i = 0; i < num_tooth_tips; i++)
normalized[i] = posterior[i] * invsum;
#endif
return;
} | 72aaf03513beaed10c4faa1993881d5c54849c5173eac4c7bbfdae0e8005fea0 | 676 |
||
PyYoshi | android_kernel_kyocera_isw12k | drivers/bluetooth/hci_brcm.c | bt_host_wake_isr |
static irqreturn_t bt_host_wake_isr(int irq, void *p)
{
BT_DBG("IRQ(%d)", irq);
serial_awake((struct hci_uart*)p);
return IRQ_HANDLED;
} |
void assert_bt_wake();
void deassert_bt_wake();
void sleep_timer_function(unsigned long data);
static void __brcm_msm_serial_clock_on(struct tty_struct *tty);
static void __brcm_msm_serial_clock_request_off(struct tty_struct *tty);
static inline int can_sleep(struct hci_uart *hu);
static inline int can_wakeup(struct hci_uart *hu);
static void serial_asleep(struct hci_uart *hu);
static void serial_awake(struct hci_uart *hu);
static void enable_bt_host_wake(struct hci_uart *hu);
static void disable_bt_host_wake(struct hci_uart *hu);
static int send_hcibrcm_cmd(u8 cmd, struct hci_uart *hu);
static int brcm_open(struct hci_uart *hu);
static int brcm_flush(struct hci_uart *hu);
static int brcm_close(struct hci_uart *hu);
static void __brcm_do_awake(struct brcm_struct *brcm);
static void brcm_device_want_to_wakeup(struct hci_uart *hu);
static void brcm_device_want_to_sleep(struct hci_uart *hu);
static void brcm_device_woke_up(struct hci_uart *hu);
static int brcm_enqueue(struct hci_uart *hu, struct sk_buff *skb);
static inline int brcm_check_data_len(struct brcm_struct *brcm, int len);
static int brcm_recv(struct hci_uart *hu, void *data, int count);
static struct sk_buff *brcm_dequeue(struct hci_uart *hu);
int brcm_init(void);
int brcm_deinit(void);
| 68bae2303947bd3547f847115ab9cb32321f3b9ed0794882dfc59851531d5006 | 158 |
|
SanderMertens | opensplice | src/tools/idlpp/code/idl_genCxxHelper.c | *
corbaTypeFromTypeSpec |
static c_char *
corbaTypeFromTypeSpec(
idl_typeBasic t)
{
c_char *typeName;
typeName = NULL;
switch (idl_typeBasicType(t)) {
case idl_short:
typeName = os_strdup("::DDS::Short");
break;
case idl_ushort:
typeName = os_strdup("::DDS::UShort");
break;
case idl_long:
typeName = os_strdup("::DDS::Long");
break;
case idl_ulong:
typeName = os_strdup("::DDS::ULong");
break;
case idl_longlong:
typeName = os_strdup("::DDS::LongLong");
break;
case idl_ulonglong:
typeName = os_strdup("::DDS::ULongLong");
break;
case idl_float:
typeName = os_strdup("::DDS::Float");
break;
case idl_double:
typeName = os_strdup("::DDS::Double");
break;
case idl_char:
typeName = os_strdup("::DDS::Char");
break;
case idl_string:
typeName = os_strdup("char *");
break;
case idl_boolean:
typeName = os_strdup("::DDS::Boolean");
break;
case idl_octet:
typeName = os_strdup("::DDS::Octet");
break;
default:
break;
}
return typeName;
} | f3e863837fea570dc5edf2e9100e6d045ca7412fb559db2a29f2a252925be0f1 | 1,142 |
||
GaloisInc | linux-deadline | net/ipv6/route.c | *ip6_route_redirect |
static struct rt6_info *ip6_route_redirect(struct in6_addr *dest,
struct in6_addr *src,
struct in6_addr *gateway,
struct net_device *dev)
{
int flags = RT6_LOOKUP_F_HAS_SADDR;
struct net *net = dev_net(dev);
struct ip6rd_flowi rdfl = {
.fl = {
.oif = dev->ifindex,
.nl_u = {
.ip6_u = {
.daddr = *dest,
.saddr = *src,
},
},
},
};
ipv6_addr_copy(&rdfl.gateway, gateway);
if (rt6_need_strict(dest))
flags |= RT6_LOOKUP_F_IFACE;
return (struct rt6_info *)fib6_rule_lookup(net, (struct flowi *)&rdfl,
flags, __ip6_route_redirect);
} |
static void ip6_rt_blackhole_update_pmtu(struct dst_entry *dst, u32 mtu);
static inline struct rt6_info *ip6_dst_alloc(struct dst_ops *ops);
static void ip6_dst_destroy(struct dst_entry *dst);
static __inline__ int rt6_check_expired(const struct rt6_info *rt);
static inline int rt6_need_strict(struct in6_addr *daddr);
static void rt6_probe(struct rt6_info *rt);
static inline void rt6_probe(struct rt6_info *rt);
static inline int rt6_check_dev(struct rt6_info *rt, int oif);
static inline int rt6_check_neigh(struct rt6_info *rt);
static struct rt6_info *rt6_select(struct fib6_node *fn, int oif, int strict);
static int __ip6_ins_rt(struct rt6_info *rt, struct nl_info *info);
int ip6_ins_rt(struct rt6_info *rt);
static struct rt6_info *rt6_alloc_clone(struct rt6_info *ort, struct in6_addr *daddr);
void ip6_route_input(struct sk_buff *skb);
int ip6_dst_blackhole(struct sock *sk, struct dst_entry **dstp, struct flowi *fl);
static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie);
static struct dst_entry *ip6_negative_advice(struct dst_entry *dst);
static void ip6_link_failure(struct sk_buff *skb);
static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu);
static inline unsigned int ipv6_advmss(struct net *net, unsigned int mtu);
int icmp6_dst_gc(void);
static void icmp6_clean_all(int (*func);
static int ip6_dst_gc(struct dst_ops *ops);
static int ipv6_get_mtu(struct net_device *dev);
int ip6_dst_hoplimit(struct dst_entry *dst);
int ip6_route_add(struct fib6_config *cfg);
static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info);
int ip6_del_rt(struct rt6_info *rt);
static int ip6_route_del(struct fib6_config *cfg);
static struct rt6_info * ip6_rt_copy(struct rt6_info *ort);
struct rt6_info *rt6_get_dflt_router(struct in6_addr *addr, struct net_device *dev);
void rt6_purge_dflt_routers(struct net *net);
int ipv6_route_ioctl(struct net *net, unsigned int cmd, void __user *arg);
static int ip6_pkt_drop(struct sk_buff *skb, u8 code, int ipstats_mib_noroutes);
static int ip6_pkt_discard(struct sk_buff *skb);
static int ip6_pkt_discard_out(struct sk_buff *skb);
static int ip6_pkt_prohibit(struct sk_buff *skb);
static int ip6_pkt_prohibit_out(struct sk_buff *skb);
static int fib6_ifdown(struct rt6_info *rt, void *arg);
void rt6_ifdown(struct net *net, struct net_device *dev);
static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg);
void rt6_mtu_change(struct net_device *dev, unsigned mtu);
static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg);
static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg);
static inline size_t rt6_nlmsg_size(void);
int rt6_dump_route(struct rt6_info *rt, void *p_arg);
static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void *arg);
void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info);
static int rt6_info_route(struct rt6_info *rt, void *p_arg);
static int ipv6_route_show(struct seq_file *m, void *v);
static int ipv6_route_open(struct inode *inode, struct file *file);
static int rt6_stats_seq_show(struct seq_file *seq, void *v);
static int rt6_stats_seq_open(struct inode *inode, struct file *file);
struct ctl_table * __net_init ipv6_route_sysctl_init(struct net *net);
static int __net_init ip6_route_net_init(struct net *net);
static void __net_exit ip6_route_net_exit(struct net *net);
int __init ip6_route_init(void);
void ip6_route_cleanup(void);
| 40d6eb2ba270a098f11837c8a99740bdccbc9489f6fb66ada074e957b262ba91 | 604 |
|
MultiNet-80211 | Hostapd | src/l2_packet/l2_packet_linux.c | l2_packet_send |
int l2_packet_send(struct l2_packet_data *l2, const u8 *dst_addr, u16 proto,
const u8 *buf, size_t len)
{
int ret;
if (l2 == NULL)
return -1;
if (l2->l2_hdr) {
ret = send(l2->fd, buf, len, 0);
if (ret < 0)
wpa_printf(MSG_ERROR, "l2_packet_send - send: %s",
strerror(errno));
} else {
struct sockaddr_ll ll;
os_memset(&ll, 0, sizeof(ll));
ll.sll_family = AF_PACKET;
ll.sll_ifindex = l2->ifindex;
ll.sll_protocol = htons(proto);
ll.sll_halen = ETH_ALEN;
os_memcpy(ll.sll_addr, dst_addr, ETH_ALEN);
ret = sendto(l2->fd, buf, len, 0, (struct sockaddr *) &ll,
sizeof(ll));
if (ret < 0) {
wpa_printf(MSG_ERROR, "l2_packet_send - sendto: %s",
strerror(errno));
}
}
return ret;
} |
int l2_packet_get_own_addr(struct l2_packet_data *l2, u8 *addr);
static void l2_packet_receive(int sock, void *eloop_ctx, void *sock_ctx);
void l2_packet_deinit(struct l2_packet_data *l2);
int l2_packet_get_ip_addr(struct l2_packet_data *l2, char *buf, size_t len);
void l2_packet_notify_auth_start(struct l2_packet_data *l2);
| a754bf461f90c41d38ee5ea67e9b22d48a107ac231f02fe934e21017dd000bf0 | 764 |
|
kayhayen | Nuitka | nuitka/build/static_src/HelpersComparisonLe.c | *COMPARE_LE_OBJECT_INT_INT |
static PyObject *COMPARE_LE_OBJECT_INT_INT(PyObject *operand1, PyObject *operand2) {
CHECK_OBJECT(operand1);
assert(PyInt_CheckExact(operand1));
#if PYTHON_VERSION < 0x300
assert(NEW_STYLE_NUMBER(operand1));
#endif
CHECK_OBJECT(operand2);
assert(PyInt_CheckExact(operand2));
#if PYTHON_VERSION < 0x300
assert(NEW_STYLE_NUMBER(operand2));
#endif
const long a = PyInt_AS_LONG(operand1);
const long b = PyInt_AS_LONG(operand2);
bool r = a <= b;
PyObject *result = BOOL_FROM(r);
Py_INCREF(result);
return result;
} |
static bool COMPARE_LE_CBOOL_INT_INT(PyObject *operand1, PyObject *operand2);
static nuitka_bool COMPARE_LE_NBOOL_INT_INT(PyObject *operand1, PyObject *operand2);
PyObject *RICH_COMPARE_LE_OBJECT_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2);
bool RICH_COMPARE_LE_CBOOL_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2);
nuitka_bool RICH_COMPARE_LE_NBOOL_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2);
static PyObject *COMPARE_LE_OBJECT_STR_STR(PyObject *operand1, PyObject *operand2);
PyObject *RICH_COMPARE_LE_OBJECT_OBJECT_STR(PyObject *operand1, PyObject *operand2);
static bool COMPARE_LE_CBOOL_STR_STR(PyObject *operand1, PyObject *operand2);
bool RICH_COMPARE_LE_CBOOL_OBJECT_STR(PyObject *operand1, PyObject *operand2);
static nuitka_bool COMPARE_LE_NBOOL_STR_STR(PyObject *operand1, PyObject *operand2);
nuitka_bool RICH_COMPARE_LE_NBOOL_OBJECT_STR(PyObject *operand1, PyObject *operand2);
PyObject *RICH_COMPARE_LE_OBJECT_STR_OBJECT(PyObject *operand1, PyObject *operand2);
bool RICH_COMPARE_LE_CBOOL_STR_OBJECT(PyObject *operand1, PyObject *operand2);
nuitka_bool RICH_COMPARE_LE_NBOOL_STR_OBJECT(PyObject *operand1, PyObject *operand2);
PyObject *RICH_COMPARE_LE_OBJECT_STR_STR(PyObject *operand1, PyObject *operand2);
bool RICH_COMPARE_LE_CBOOL_STR_STR(PyObject *operand1, PyObject *operand2);
nuitka_bool RICH_COMPARE_LE_NBOOL_STR_STR(PyObject *operand1, PyObject *operand2);
static bool COMPARE_LE_CBOOL_BYTES_BYTES(PyObject *operand1, PyObject *operand2);
bool RICH_COMPARE_LE_CBOOL_OBJECT_BYTES(PyObject *operand1, PyObject *operand2);
static nuitka_bool COMPARE_LE_NBOOL_BYTES_BYTES(PyObject *operand1, PyObject *operand2);
nuitka_bool RICH_COMPARE_LE_NBOOL_OBJECT_BYTES(PyObject *operand1, PyObject *operand2);
static PyObject *COMPARE_LE_OBJECT_BYTES_BYTES(PyObject *operand1, PyObject *operand2);
PyObject *RICH_COMPARE_LE_OBJECT_BYTES_OBJECT(PyObject *operand1, PyObject *operand2);
bool RICH_COMPARE_LE_CBOOL_BYTES_OBJECT(PyObject *operand1, PyObject *operand2);
nuitka_bool RICH_COMPARE_LE_NBOOL_BYTES_OBJECT(PyObject *operand1, PyObject *operand2);
PyObject *RICH_COMPARE_LE_OBJECT_BYTES_BYTES(PyObject *operand1, PyObject *operand2);
bool RICH_COMPARE_LE_CBOOL_BYTES_BYTES(PyObject *operand1, PyObject *operand2);
nuitka_bool RICH_COMPARE_LE_NBOOL_BYTES_BYTES(PyObject *operand1, PyObject *operand2);
PyObject *RICH_COMPARE_LE_OBJECT_INT_INT(PyObject *operand1, PyObject *operand2);
bool RICH_COMPARE_LE_CBOOL_INT_INT(PyObject *operand1, PyObject *operand2);
nuitka_bool RICH_COMPARE_LE_NBOOL_INT_INT(PyObject *operand1, PyObject *operand2);
PyObject *RICH_COMPARE_LE_OBJECT_OBJECT_INT(PyObject *operand1, PyObject *operand2);
bool RICH_COMPARE_LE_CBOOL_OBJECT_INT(PyObject *operand1, PyObject *operand2);
nuitka_bool RICH_COMPARE_LE_NBOOL_OBJECT_INT(PyObject *operand1, PyObject *operand2);
PyObject *RICH_COMPARE_LE_OBJECT_INT_OBJECT(PyObject *operand1, PyObject *operand2);
bool RICH_COMPARE_LE_CBOOL_INT_OBJECT(PyObject *operand1, PyObject *operand2);
nuitka_bool RICH_COMPARE_LE_NBOOL_INT_OBJECT(PyObject *operand1, PyObject *operand2);
static PyObject *COMPARE_LE_OBJECT_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2);
PyObject *RICH_COMPARE_LE_OBJECT_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2);
static bool COMPARE_LE_CBOOL_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2);
bool RICH_COMPARE_LE_CBOOL_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2);
static nuitka_bool COMPARE_LE_NBOOL_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2);
nuitka_bool RICH_COMPARE_LE_NBOOL_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2);
PyObject *RICH_COMPARE_LE_OBJECT_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2);
bool RICH_COMPARE_LE_CBOOL_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2);
nuitka_bool RICH_COMPARE_LE_NBOOL_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2);
PyObject *RICH_COMPARE_LE_OBJECT_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2);
bool RICH_COMPARE_LE_CBOOL_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2);
nuitka_bool RICH_COMPARE_LE_NBOOL_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2);
static PyObject *COMPARE_LE_OBJECT_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2);
PyObject *RICH_COMPARE_LE_OBJECT_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2);
static bool COMPARE_LE_CBOOL_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2);
bool RICH_COMPARE_LE_CBOOL_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2);
static nuitka_bool COMPARE_LE_NBOOL_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2);
nuitka_bool RICH_COMPARE_LE_NBOOL_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2);
PyObject *RICH_COMPARE_LE_OBJECT_OBJECT_TUPLE(PyObject *operand1, PyObject *operand2);
bool RICH_COMPARE_LE_CBOOL_OBJECT_TUPLE(PyObject *operand1, PyObject *operand2);
nuitka_bool RICH_COMPARE_LE_NBOOL_OBJECT_TUPLE(PyObject *operand1, PyObject *operand2);
PyObject *RICH_COMPARE_LE_OBJECT_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2);
bool RICH_COMPARE_LE_CBOOL_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2);
nuitka_bool RICH_COMPARE_LE_NBOOL_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2);
static PyObject *COMPARE_LE_OBJECT_LIST_LIST(PyObject *operand1, PyObject *operand2);
PyObject *RICH_COMPARE_LE_OBJECT_LIST_LIST(PyObject *operand1, PyObject *operand2);
static bool COMPARE_LE_CBOOL_LIST_LIST(PyObject *operand1, PyObject *operand2);
bool RICH_COMPARE_LE_CBOOL_LIST_LIST(PyObject *operand1, PyObject *operand2);
static nuitka_bool COMPARE_LE_NBOOL_LIST_LIST(PyObject *operand1, PyObject *operand2);
nuitka_bool RICH_COMPARE_LE_NBOOL_LIST_LIST(PyObject *operand1, PyObject *operand2);
PyObject *RICH_COMPARE_LE_OBJECT_OBJECT_LIST(PyObject *operand1, PyObject *operand2);
bool RICH_COMPARE_LE_CBOOL_OBJECT_LIST(PyObject *operand1, PyObject *operand2);
nuitka_bool RICH_COMPARE_LE_NBOOL_OBJECT_LIST(PyObject *operand1, PyObject *operand2);
PyObject *RICH_COMPARE_LE_OBJECT_LIST_OBJECT(PyObject *operand1, PyObject *operand2);
bool RICH_COMPARE_LE_CBOOL_LIST_OBJECT(PyObject *operand1, PyObject *operand2);
nuitka_bool RICH_COMPARE_LE_NBOOL_LIST_OBJECT(PyObject *operand1, PyObject *operand2);
| ade145a9a0ee41063fe94e331f6dff85a986b4941a098209ea0060463e067b36 | 568 |
|
ducis | robotic-stuff | Test/IRCom/checkedcom.c | StateProc_CheckedComReplying |
void StateProc_CheckedComReplying(){
} |
unsigned char CountBitsDW(unsigned long dw);
BOOL CheckedComTryToStartReceiving();
void CheckedComStartSending(unsigned char data);
void StateProc_CheckedComIdle();
void StateProc_CheckedComTestIdle();
void StateProc_CheckedComReceiving();
void StateProc_CheckedComSending();
void StateProc_CheckedComWaitingForReply();
void StateProc_CheckedComReceivingReply();
void StateProc_CheckedComReceivingComplete();
| f9464ea1e8c4207720f92270ce805d0b36abb2b49c943e7aa67e317b83574093 | 40 |
|
ma-tech | Woolz | libWlz/WlzMeshGen.c | WlzCMeshElmsFromLBTNode2D4 |
static WlzErrorNum WlzCMeshElmsFromLBTNode2D4(WlzCMesh2D *mesh,
WlzCMeshElm2D **mElm,
WlzCMeshNod2D **mNod,
WlzDVertex2 *nPos,
int *dstNElm)
{
WlzErrorNum errNum = WLZ_ERR_NONE;
if(errNum == WLZ_ERR_NONE)
{
mElm[0] = WlzCMeshNewElm2D(mesh, mNod[0], mNod[1], mNod[5], 0, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
mElm[1] = WlzCMeshNewElm2D(mesh, mNod[1], mNod[2], mNod[3], 0, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
mElm[2] = WlzCMeshNewElm2D(mesh, mNod[3], mNod[4], mNod[5], 0, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
mElm[3] = WlzCMeshNewElm2D(mesh, mNod[5], mNod[6], mNod[0], 0, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
mElm[4] = WlzCMeshNewElm2D(mesh, mNod[1], mNod[3], mNod[5], 0, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
*dstNElm = 5;
}
return(errNum);
} |
WlzCMesh2D *WlzCMeshNew2D(WlzErrorNum *dstErr);
WlzCMesh2D5 *WlzCMeshNew2D5(WlzErrorNum *dstErr);
WlzCMesh3D *WlzCMeshNew3D(WlzErrorNum *dstErr);
static void WlzCMeshAddNodToGrid2D(WlzCMesh2D *mesh, WlzCMeshNod2D *nod);
static void WlzCMeshAddNodToGrid2D5(WlzCMesh2D5 *mesh, WlzCMeshNod2D5 *nod);
static void WlzCMeshAddNodToGrid3D(WlzCMesh3D *mesh, WlzCMeshNod3D *nod);
static WlzErrorNum WlzCMeshAddElmToGrid2D(WlzCMesh2D *mesh, WlzCMeshElm2D *elm);
static WlzErrorNum WlzCMeshAddElmToGrid3D(WlzCMesh3D *mesh, WlzCMeshElm3D *elm);
static void WlzCMeshRemNodFromGrid2D(WlzCMesh2D *mesh, WlzCMeshNod2D *nod);
static void WlzCMeshRemNodFromGrid3D(WlzCMesh3D *mesh, WlzCMeshNod3D *nod);
static void WlzCMeshRemElmFromGrid2D(WlzCMesh2D *mesh, WlzCMeshElm2D *elm);
static void WlzCMeshRemElmFromGrid3D(WlzCMesh3D *mesh, WlzCMeshElm3D *elm);
WlzCMeshNod2D *WlzCMeshAllocNod2D(WlzCMesh2D *mesh);
WlzCMeshNod2D5 *WlzCMeshAllocNod2D5(WlzCMesh2D5 *mesh);
WlzCMeshNod3D *WlzCMeshAllocNod3D(WlzCMesh3D *mesh);
WlzCMeshElm2D *WlzCMeshAllocElm2D(WlzCMesh2D *mesh);
WlzCMeshElm2D5 *WlzCMeshAllocElm2D5(WlzCMesh2D5 *mesh);
WlzCMeshElm3D *WlzCMeshAllocElm3D(WlzCMesh3D *mesh);
static WlzCMeshFace *WlzCMeshFindOppFce(WlzCMeshFace *gFce);
static void WlzCMeshNodAddEdu3D(WlzCMeshNod3D *nod, WlzCMeshEdgU3D *edu);
WlzErrorNum WlzCMeshFree(WlzCMeshP mesh);
WlzErrorNum WlzCMeshFree2D(WlzCMesh2D *mesh);
WlzErrorNum WlzCMeshFree2D5(WlzCMesh2D5 *mesh);
WlzErrorNum WlzCMeshFree3D(WlzCMesh3D *mesh);
WlzErrorNum WlzCMeshDelNod2D(WlzCMesh2D *mesh, WlzCMeshNod2D *nod);
WlzErrorNum WlzCMeshDelNod2D5(WlzCMesh2D5 *mesh, WlzCMeshNod2D5 *nod);
WlzErrorNum WlzCMeshDelNod3D(WlzCMesh3D *mesh, WlzCMeshNod3D *nod);
WlzErrorNum WlzCMeshDelElm2D(WlzCMesh2D *mesh, WlzCMeshElm2D *elm);
WlzErrorNum WlzCMeshDelElm2D5(WlzCMesh2D5 *mesh, WlzCMeshElm2D5 *elm);
WlzErrorNum WlzCMeshDelElm3D(WlzCMesh3D *mesh, WlzCMeshElm3D *elm);
static void WlzCMeshEntMarkFree(int *idx);
void WlzCMeshNodFree2D(WlzCMesh2D *mesh, WlzCMeshNod2D *nod);
void WlzCMeshNodFree2D5(WlzCMesh2D5 *mesh, WlzCMeshNod2D5 *nod);
void WlzCMeshNodFree3D(WlzCMesh3D *mesh, WlzCMeshNod3D *nod);
void WlzCMeshElmFree2D(WlzCMesh2D *mesh, WlzCMeshElm2D *elm);
void WlzCMeshElmFree2D5(WlzCMesh2D5 *mesh, WlzCMeshElm2D5 *elm);
void WlzCMeshElmFree3D(WlzCMesh3D *mesh, WlzCMeshElm3D *elm);
void WlzCMeshDelUnusedNodes3D(WlzCMesh3D *mesh);
void WlzCMeshDelUnusedNodes2D5(WlzCMesh2D5 *mesh);
void WlzCMeshDelUnusedNodes2D(WlzCMesh2D *mesh);
double WlzCMeshElmMinEdgLnSq2D(WlzCMeshElm2D *elm);
double WlzCMeshElmMinEdgLnSq3D(WlzCMeshElm3D *elm);
static void WlzCMeshFreeGridCells2D(WlzCMesh2D *mesh);
static void WlzCMeshFreeGridCells2D5(WlzCMesh2D5 *mesh);
static void WlzCMeshFreeGridCells3D(WlzCMesh3D *mesh);
static WlzErrorNum WlzCMeshAllocGridCells2D(WlzCMesh2D *mesh);
static WlzErrorNum WlzCMeshAllocGridCells2D5(WlzCMesh2D5 *mesh);
static WlzErrorNum WlzCMeshAllocGridCells3D(WlzCMesh3D *mesh);
WlzErrorNum WlzCMeshReassignGridCells2D(WlzCMesh2D *mesh, int newNumNod);
WlzErrorNum WlzCMeshReassignGridCells2D5(WlzCMesh2D5 *mesh, int newNumNod);
WlzErrorNum WlzCMeshReassignGridCells3D(WlzCMesh3D *mesh, int newNumNod);
static double WlzCMeshCompGridBSz2D(int nN, double nPC, WlzDVertex2 mSz);
static double WlzCMeshCompGridBSz2D5(int nN, double nPC, WlzDVertex3 mSz);
static double WlzCMeshCompGridBSz3D(int nN, double nPC, WlzDVertex3 mSz);
static WlzIVertex2 WlzCMeshCellIdxVtx2D(WlzCMesh2D *mesh, WlzDVertex2 vtx);
static WlzIVertex3 WlzCMeshCellIdxVtx2D5(WlzCMesh2D5 *mesh, WlzDVertex3 vtx);
static WlzIVertex3 WlzCMeshCellIdxVtx3D(WlzCMesh3D *mesh, WlzDVertex3 vtx);
static double WlzCMeshAddTolToBndAndClamp(double b, double c, double t);
int WlzCMeshClosestNod2D(WlzCMesh2D *mesh, WlzDVertex2 pos);
int WlzCMeshClosestNod2D5(WlzCMesh2D5 *mesh, WlzDVertex3 p);
int WlzCMeshClosestNod3D(WlzCMesh3D *mesh, WlzDVertex3 pos);
int WlzCMeshElmEnclosesPos2D(WlzCMeshElm2D *elm, WlzDVertex2 gPos);
int WlzCMeshElmEnclosesPos2D5(WlzCMeshElm2D5 *elm, WlzDVertex3 gPos);
int WlzCMeshElmEnclosesPos3D(WlzCMeshElm3D *elm, WlzDVertex3 gPos);
WlzCMesh2D5 *WlzCMeshFromGM(WlzGMModel *model, WlzErrorNum *dstErr);
static WlzCMeshEdgU2D *WlzCMeshEdgUseFindOpp2D(WlzCMeshEdgU2D *gEdu);
static WlzCMeshEdgU2D5 *WlzCMeshEdgUseFindOpp2D5(WlzCMeshEdgU2D5 *gEdu);
void WlzCMeshDbgOutVTK2D(FILE *fP, WlzCMesh2D *mesh);
void WlzCMeshDbgOutVTK3D(FILE *fP, WlzCMesh3D *mesh);
void WlzCMeshDbgOutVTK(FILE *fP, WlzCMeshP mesh);
WlzErrorNum WlzCMeshElmFuse2D(WlzCMesh2D *mesh, WlzCMeshElm2D *gElm);
static WlzErrorNum WlzCMeshElmFuse2D3(WlzCMesh2D *mesh, WlzCMeshElm2D *gElm);
| dc6c7744fe06d258b2ac1d6a1fafe4b5127067bba96f430fe0508d2e4f61a531 | 857 |
|
Baastyr | semc-es209ra-kernel | lib/string.c | *strim |
char *strim(char *s)
{
size_t size;
char *end;
s = skip_spaces(s);
size = strlen(s);
if (!size)
return s;
end = s + size - 1;
while (end >= s && isspace(*end))
end--;
*(end + 1) = '\0';
return s;
} |
int strnicmp(const char *s1, const char *s2, size_t len);
int strcasecmp(const char *s1, const char *s2);
int strncasecmp(const char *s1, const char *s2, size_t n);
char *strcpy(char *dest, const char *src);
char *strncpy(char *dest, const char *src, size_t count);
size_t strlcpy(char *dest, const char *src, size_t size);
char *skip_spaces(const char *str);
char *strcat(char *dest, const char *src);
char *strncat(char *dest, const char *src, size_t count);
size_t strlcat(char *dest, const char *src, size_t count);
int strcmp(const char *cs, const char *ct);
int strncmp(const char *cs, const char *ct, size_t count);
char *strchr(const char *s, int c);
char *strrchr(const char *s, int c);
char *strnchr(const char *s, size_t count, int c);
char *strstrip(char *s);
size_t strlen(const char *s);
size_t strnlen(const char *s, size_t count);
size_t strspn(const char *s, const char *accept);
size_t strcspn(const char *s, const char *reject);
char *strpbrk(const char *cs, const char *ct);
char *strsep(char **s, const char *ct);
bool sysfs_streq(const char *s1, const char *s2);
void *memset(void *s, int c, size_t count);
void *memcpy(void *dest, const void *src, size_t count);
void *memmove(void *dest, const void *src, size_t count);
int memcmp(const void *cs, const void *ct, size_t count);
void *memscan(void *addr, int c, size_t size);
char *strstr(const char *s1, const char *s2);
void *memchr(const void *s, int c, size_t n);
| 9563c3f30ee8d70116096c96def23312b8534c91618548e6295c81f38344a345 | 201 |
|
reidrac | dan64 | init/main.c |
void
load_data_write |
void
load_data_write(uint8_t byte, void *arg)
{
uint16_t *addr = (uint16_t *)arg;
sram_write(*addr, &byte, 1);
(*addr)++;
} | 8f3d53f80e2010081ec09ddf3c07ec9801418f2d12eb5546a29c1839fc5ba08d | 128 |
||
ImageMagick | glib | gio/gcancellable.c | *
g_cancellable_source_new |
GSource *
g_cancellable_source_new (GCancellable *cancellable)
{
GSource *source;
GCancellableSource *cancellable_source;
source = g_source_new (&cancellable_source_funcs, sizeof (GCancellableSource));
g_source_set_name (source, "GCancellable");
g_source_set_dispose_function (source, cancellable_source_dispose);
cancellable_source = (GCancellableSource *)source;
if (cancellable)
{
cancellable_source->cancellable = g_object_ref (cancellable);
cancellable_source->cancelled_handler =
g_signal_connect (cancellable, "cancelled",
G_CALLBACK (cancellable_source_cancelled),
source);
if (g_cancellable_is_cancelled (cancellable))
g_source_set_ready_time (source, 0);
}
return source;
} | 433d20db84acb0727c66b719859027ee3361a1af65b9e2b1e0c5bc96be2c0f7e | 806 |