type stringclasses 5
values | content stringlengths 9 163k |
|---|---|
includes | #include <device/pciexp.h> |
includes | #include <device/hypertransport.h> |
includes | #include <pc80/i8259.h> |
includes | #include <kconfig.h> |
includes | #include <vendorcode/google/chromeos/chromeos.h> |
functions | u8 pci_moving_config8(struct device *dev, unsigned int reg)
{
u8 value, ones, zeroes;
value = pci_read_config8(dev, reg);
pci_write_config8(dev, reg, 0xff);
ones = pci_read_config8(dev, reg);
pci_write_config8(dev, reg, 0x00);
zeroes = pci_read_config8(dev, reg);
pci_write_config8(dev, reg, value);
return ... |
functions | u16 pci_moving_config16(struct device *dev, unsigned int reg)
{
u16 value, ones, zeroes;
value = pci_read_config16(dev, reg);
pci_write_config16(dev, reg, 0xffff);
ones = pci_read_config16(dev, reg);
pci_write_config16(dev, reg, 0x0000);
zeroes = pci_read_config16(dev, reg);
pci_write_config16(dev, reg, valu... |
functions | u32 pci_moving_config32(struct device *dev, unsigned int reg)
{
u32 value, ones, zeroes;
value = pci_read_config32(dev, reg);
pci_write_config32(dev, reg, 0xffffffff);
ones = pci_read_config32(dev, reg);
pci_write_config32(dev, reg, 0x00000000);
zeroes = pci_read_config32(dev, reg);
pci_write_config32(dev, r... |
functions | unsigned pci_find_next_capability(struct device *dev, unsigned cap,
unsigned last)
{
unsigned pos = 0;
u16 status;
unsigned reps = 48;
status = pci_read_config16(dev, PCI_STATUS);
if (!(status & PCI_STATUS_CAP_LIST))
return 0;
switch (dev->hdr_type & 0x7f) {
case PCI_HEADER_TYPE_NORMAL:
case PCI_HEADE... |
functions | unsigned pci_find_capability(device_t dev, unsigned cap)
{
return pci_find_next_capability(dev, cap, 0);
} |
functions | else if (attr & PCI_BASE_ADDRESS_SPACE_IO) {
/* An I/O mapped base address. */
attr &= PCI_BASE_ADDRESS_IO_ATTR_MASK;
resource->flags |= IORESOURCE_IO;
/* I don't want to deal with 32bit I/O resources. */
resource->limit = 0xffff;
} |
functions | else if (attr == PCI_BASE_ADDRESS_MEM_LIMIT_1M) {
/* 1MB limit. */
resource->limit = 0x000fffffUL;
} |
functions | else if (attr == PCI_BASE_ADDRESS_MEM_LIMIT_64) {
/* 64bit limit. */
resource->limit = 0xffffffffffffffffULL;
resource->flags |= IORESOURCE_PCI64;
} |
functions | void pci_get_rom_resource(struct device *dev, unsigned long index)
{
struct resource *resource;
unsigned long value;
resource_t moving;
/* Initialize the resources to nothing. */
resource = new_resource(dev, index);
/* Get the initial value. */
value = pci_read_config32(dev, index);
/* See which bits move. *... |
functions | void pci_read_bases(struct device *dev, unsigned int howmany)
{
unsigned long index;
for (index = PCI_BASE_ADDRESS_0;
(index < PCI_BASE_ADDRESS_0 + (howmany << 2));) {
struct resource *resource;
resource = pci_get_resource(dev, index);
index += (resource->flags & IORESOURCE_PCI64) ? 8 : 4;
} |
functions | void pci_record_bridge_resource(struct device *dev, resource_t moving,
unsigned index, unsigned long type)
{
struct resource *resource;
unsigned long gran;
resource_t step;
resource = NULL;
if (!moving)
return;
/* Initialize the constraints on the current bus. */
resource = new_resource(dev, inde... |
functions | void pci_bridge_read_bases(struct device *dev)
{
resource_t moving_base, moving_limit, moving;
/* See if the bridge I/O resources are implemented. */
moving_base = ((u32) pci_moving_config8(dev, PCI_IO_BASE)) << 8;
moving_base |=
((u32) pci_moving_config16(dev, PCI_IO_BASE_UPPER16)) << 16;
moving_limit = ((u3... |
functions | void pci_dev_read_resources(struct device *dev)
{
pci_read_bases(dev, 6);
pci_get_rom_resource(dev, PCI_ROM_ADDRESS);
} |
functions | void pci_bus_read_resources(struct device *dev)
{
pci_bridge_read_bases(dev);
pci_read_bases(dev, 2);
pci_get_rom_resource(dev, PCI_ROM_ADDRESS1);
} |
functions | void pci_domain_read_resources(struct device *dev)
{
struct resource *res;
/* Initialize the system-wide I/O space constraints. */
res = new_resource(dev, IOINDEX_SUBTRACTIVE(0, 0));
res->limit = 0xffffUL;
res->flags = IORESOURCE_IO | IORESOURCE_SUBTRACTIVE |
IORESOURCE_ASSIGNED;
/* Initialize the system... |
functions | void pci_set_resource(struct device *dev, struct resource *resource)
{
resource_t base, end;
/* Make certain the resource has actually been assigned a value. */
if (!(resource->flags & IORESOURCE_ASSIGNED)) {
printk(BIOS_ERR, "ERROR: %s %02lx %s size: 0x%010llx not "
"assigned\n", dev_path(dev), resource... |
functions | else if (resource->index == PCI_IO_BASE) {
/* Set the I/O ranges. */
pci_write_config8(dev, PCI_IO_BASE, base >> 8);
pci_write_config16(dev, PCI_IO_BASE_UPPER16, base >> 16);
pci_write_config8(dev, PCI_IO_LIMIT, end >> 8);
pci_write_config16(dev, PCI_IO_LIMIT_UPPER16, end >> 16);
} |
functions | else if (resource->index == PCI_MEMORY_BASE) {
/* Set the memory range. */
pci_write_config16(dev, PCI_MEMORY_BASE, base >> 16);
pci_write_config16(dev, PCI_MEMORY_LIMIT, end >> 16);
} |
functions | else if (resource->index == PCI_PREF_MEMORY_BASE) {
/* Set the prefetchable memory range. */
pci_write_config16(dev, PCI_PREF_MEMORY_BASE, base >> 16);
pci_write_config32(dev, PCI_PREF_BASE_UPPER32, base >> 32);
pci_write_config16(dev, PCI_PREF_MEMORY_LIMIT, end >> 16);
pci_write_config32(dev, PCI_PREF_LIMIT_... |
functions | void pci_dev_set_resources(struct device *dev)
{
struct resource *res;
struct bus *bus;
u8 line;
for (res = dev->resource_list; res; res = res->next)
pci_set_resource(dev, res);
for (bus = dev->link_list; bus; bus = bus->next) {
if (bus->children)
assign_resources(bus);
} |
functions | void pci_dev_enable_resources(struct device *dev)
{
const struct pci_operations *ops;
u16 command;
/* Set the subsystem vendor and device ID for mainboard devices. */
ops = ops_pci(dev);
if (dev->on_mainboard && ops && ops->set_subsystem) {
if (CONFIG_SUBSYSTEM_VENDOR_ID)
dev->subsystem_vendor = CONFIG_SUBSY... |
functions | void pci_bus_enable_resources(struct device *dev)
{
u16 ctrl;
/*
* Enable I/O in command register if there is VGA card
* connected with (even it does not claim I/O resource).
*/
if (dev->link_list->bridge_ctrl & PCI_BRIDGE_CTL_VGA)
dev->command |= PCI_COMMAND_IO;
ctrl = pci_read_config16(dev, PCI_BRIDGE_CO... |
functions | void pci_bus_reset(struct bus *bus)
{
u16 ctl;
ctl = pci_read_config16(bus->dev, PCI_BRIDGE_CONTROL);
ctl |= PCI_BRIDGE_CTL_BUS_RESET;
pci_write_config16(bus->dev, PCI_BRIDGE_CONTROL, ctl);
mdelay(10);
ctl &= ~PCI_BRIDGE_CTL_BUS_RESET;
pci_write_config16(bus->dev, PCI_BRIDGE_CONTROL, ctl);
delay(1);
} |
functions | void pci_dev_set_subsystem(struct device *dev, unsigned vendor, unsigned device)
{
pci_write_config32(dev, PCI_SUBSYSTEM_VENDOR_ID,
((device & 0xffff) << 16) | (vendor & 0xffff));
} |
functions | int should_run_oprom(struct device *dev)
{
static int should_run = -1;
if (should_run >= 0)
return should_run;
/* Don't run VGA option ROMs, unless we have to print
* something on the screen before the kernel is loaded.
*/
should_run = !IS_ENABLED(CONFIG_BOOTMODE_STRAPS) ||
developer_mode_enabled() || rec... |
functions | int should_load_oprom(struct device *dev)
{
/* If S3_VGA_ROM_RUN is disabled, skip running VGA option
* ROMs when coming out of an S3 resume.
*/
if (!IS_ENABLED(CONFIG_S3_VGA_ROM_RUN) && acpi_is_wakeup_s3() &&
((dev->class >> 8) == PCI_CLASS_DISPLAY_VGA))
return 0;
if (IS_ENABLED(CONFIG_ALWAYS_LOAD_OPROM))
... |
functions | void pci_dev_init(struct device *dev)
{
#if CONFIG_VGA_ROM_RUN
struct rom_header *rom, *ram;
/* Only execute VGA ROMs. */
if (((dev->class >> 8) != PCI_CLASS_DISPLAY_VGA))
return;
if (!should_load_oprom(dev))
return;
rom = pci_rom_probe(dev);
if (rom == NULL)
return;
ram = pci_rom_load(dev, rom);
if (... |
functions | int device_id_match(struct pci_driver *driver, unsigned short device_id)
{
if (driver->devices) {
unsigned short check_id;
const unsigned short *device_list = driver->devices;
while ((check_id = *device_list++) != 0)
if (check_id == device_id)
return 1;
} |
functions | void set_pci_ops(struct device *dev)
{
struct pci_driver *driver;
if (dev->ops)
return;
/*
* Look through the list of setup drivers and find one for
* this PCI device.
*/
for (driver = &_pci_drivers[0]; driver != &_epci_drivers[0]; driver++) {
if ((driver->vendor == dev->vendor) &&
device_id_match... |
functions | device_t pci_probe_dev(device_t dev, struct bus *bus, unsigned devfn)
{
u32 id, class;
u8 hdr_type;
/* Detect if a device is present. */
if (!dev) {
struct device dummy;
dummy.bus = bus;
dummy.path.type = DEVICE_PATH_PCI;
dummy.path.pci.devfn = devfn;
id = pci_read_config32(&dummy, PCI_VENDOR_ID);
/*... |
functions | int pci_match_simple_dev(device_t dev, pci_devfn_t sdev)
{
return dev->bus->secondary == PCI_DEV2SEGBUS(sdev) &&
dev->path.pci.devfn == PCI_DEV2DEVFN(sdev);
} |
functions | void pci_scan_bus(struct bus *bus, unsigned min_devfn,
unsigned max_devfn)
{
unsigned int devfn;
struct device *old_devices;
printk(BIOS_DEBUG, "PCI: pci_scan_bus for bus %02x\n", bus->secondary);
/* Maximum sane devfn is 0xFF. */
if (max_devfn > 0xff) {
printk(BIOS_ERR, "PCI: pci_scan_bus limits devfn %x... |
functions | void pci_bridge_route(struct bus *link, scan_state state)
{
struct device *dev = link->dev;
struct bus *parent = dev->bus;
u32 reg, buses = 0;
if (state == PCI_ROUTE_SCAN) {
link->secondary = parent->subordinate + 1;
link->subordinate = link->secondary;
} |
functions | else if (state == PCI_ROUTE_SCAN) {
buses |= ((u32) link->secondary & 0xff) << 8;
buses |= 0xff << 16; /* MAX PCI_BUS number here */
} |
functions | else if (state == PCI_ROUTE_FINAL) {
buses |= parent->secondary & 0xff;
buses |= ((u32) link->secondary & 0xff) << 8;
buses |= ((u32) link->subordinate & 0xff) << 16;
} |
functions | void pci_scan_bridge(struct device *dev)
{
do_pci_scan_bridge(dev, pci_scan_bus);
} |
functions | void pci_domain_scan_bus(device_t dev)
{
struct bus *link = dev->link_list;
pci_scan_bus(link, PCI_DEVFN(0, 0), 0xff);
} |
functions | int swizzle_irq_pins(device_t dev, device_t *parent_bridge)
{
device_t parent; /* Our current device's parent device */
device_t child; /* The child device of the parent */
uint8_t parent_bus = 0; /* Parent Bus number */
uint16_t parent_devfn = 0; /* Parent Device and Function number */
uint16_t child_devfn = 0;... |
functions | int get_pci_irq_pins(device_t dev, device_t *parent_bdg)
{
uint8_t bus = 0; /* The bus this device is on */
uint16_t devfn = 0; /* This device's device and function numbers */
uint8_t int_pin = 0; /* Interrupt pin used by the device */
uint8_t target_pin = 0; /* Interrupt pin we want to assign an IRQ to */
/* Mak... |
functions | void pci_assign_irqs(unsigned bus, unsigned slot,
const unsigned char pIntAtoD[4])
{
unsigned int funct;
device_t pdev;
u8 line, irq;
/* Each slot may contain up to eight functions. */
for (funct = 0; funct < 8; funct++) {
pdev = dev_find_slot(bus, (slot << 3) + funct);
if (!pdev)
continue;
line... |
functions | void timer_handler(struct regs *r)
{
/* Increment our 'tick count' */
timer_ticks++;
/* Every 18 clocks (approximately 1 second), we will
* display a message on the screen */
if (timer_ticks % 18 == 0)
{
// puts("One second has passed\n");
} |
functions | void timer_install()
{
/* Installs 'timer_handler' to IRQ0 */
irq_install_handler(0, timer_handler);
} |
functions | void timer_wait(int ticks)
{
unsigned long eticks;
eticks = timer_ticks + ticks;
while(timer_ticks < eticks);
} |
includes | #include <assert.h> |
includes | #include <stdlib.h> |
functions | void dt_gui_presets_init()
{
// remove auto generated presets from plugins, not the user included ones.
DT_DEBUG_SQLITE3_EXEC(dt_database_get(darktable.db), "DELETE FROM data.presets WHERE writeprotect = 1", NULL,
NULL, NULL);
} |
functions | void dt_gui_presets_add_generic(const char *name, dt_dev_operation_t op, const int32_t version,
const void *params, const int32_t params_size,
const int32_t enabled,
const dt_develop_blend_colorspace_t blend_cst)
{
dt_deve... |
functions | void dt_gui_presets_add_with_blendop(
const char *name, dt_dev_operation_t op, const int32_t version,
const void *params, const int32_t params_size,
const void *blend_params, const int32_t enabled)
{
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2(
dt_database_get(darktable.db),
"INSERT OR ... |
functions | void menuitem_delete_preset(GtkMenuItem *menuitem, dt_iop_module_t *module)
{
sqlite3_stmt *stmt;
int writeprotect = -1;
gchar *name = get_active_preset_name(module, &writeprotect);
if(name == NULL) return;
if(writeprotect)
{
dt_control_log(_("preset `%s' is write-protected, can't delete!"), name);
... |
functions | void edit_preset_response(GtkDialog *dialog, gint response_id, dt_gui_presets_edit_dialog_t *g)
{
gint is_new = 0;
if(response_id == GTK_RESPONSE_ACCEPT)
{
sqlite3_stmt *stmt;
const gchar *name = gtk_entry_get_text(g->name);
if(((g->old_id >= 0) && (strcmp(g->original_name, name) != 0)) || (g->old_i... |
functions | name
if(dlg_ret != GTK_RESPONSE_YES)
{
return;
} |
functions | void check_buttons_activated(GtkCheckButton *button, dt_gui_presets_edit_dialog_t *g)
{
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(g->autoapply))
|| gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(g->filter)))
{
gtk_widget_set_visible(GTK_WIDGET(g->details), TRUE);
gtk_widget_set_no_show_all(GTK_... |
functions | void edit_preset(const char *name_in, dt_iop_module_t *module)
{
gchar *name = NULL;
if(name_in == NULL)
{
int writeprotect = -1;
name = get_active_preset_name(module, &writeprotect);
if(name == NULL) return;
if(writeprotect)
{
dt_control_log(_("preset `%s' is write-protected! can't edit... |
functions | void menuitem_edit_preset(GtkMenuItem *menuitem, dt_iop_module_t *module)
{
edit_preset(NULL, module);
} |
functions | void menuitem_update_preset(GtkMenuItem *menuitem, dt_iop_module_t *module)
{
gchar *name = g_object_get_data(G_OBJECT(menuitem), "dt-preset-name");
gint res = GTK_RESPONSE_YES;
if(dt_conf_get_bool("plugins/lighttable/preset/ask_before_delete_preset"))
{
GtkWidget *window = dt_ui_main_window(darktable.gui... |
functions | void menuitem_new_preset(GtkMenuItem *menuitem, dt_iop_module_t *module)
{
// add new preset
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),
"DELETE FROM data.presets"
" WHERE name=?1 AND operation=?2 AND op_version=?3", -1... |
functions | void apply_preset(const gchar* name, dt_iop_module_t *module)
{
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2
(dt_database_get(darktable.db),
"SELECT op_params, enabled, blendop_params, blendop_version, writeprotect"
" FROM data.presets"
" WHERE operation = ?1 AND op_version = ?2 AND name = ?3"... |
functions | void menuitem_pick_preset(GtkMenuItem *menuitem, dt_iop_module_t *module)
{
gchar *name = g_object_get_data(G_OBJECT(menuitem), "dt-preset-name");
apply_preset(name, module);
} |
functions | gboolean dt_gui_presets_autoapply_for_module(dt_iop_module_t *module)
{
dt_image_t *image = &module->dev->image_storage;
gchar *workflow = dt_conf_get_string("plugins/darkroom/workflow");
const gboolean is_display_referred = strcmp(workflow, "display-referred") == 0;
const gboolean is_scene_referred = strcmp(w... |
functions | gboolean menuitem_button_released_preset(GtkMenuItem *menuitem, GdkEventButton *event, dt_iop_module_t *module)
{
if (event->button == 1 || (module->flags() & IOP_FLAGS_ONE_INSTANCE))
{
menuitem_pick_preset(menuitem, module);
} |
functions | else if (event->button == 2)
{
dt_iop_module_t *new_module = dt_iop_gui_duplicate(module, FALSE);
if (new_module)
menuitem_pick_preset(menuitem, new_module);
} |
functions | gboolean menuitem_manage_quick_presets_traverse(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter,
gpointer data)
{
gchar **txt = (gchar **)data;
gchar *preset = NULL;
gchar *iop_name = NULL;
gboolean active = FALSE;
gtk_tree_model_get(model, iter... |
functions | void menuitem_manage_quick_presets_toggle(GtkCellRendererToggle *cell_renderer, gchar *path,
gpointer tree_view)
{
GtkTreeModel *model;
GtkTreeIter iter;
model = gtk_tree_view_get_model(tree_view);
if(gtk_tree_model_get_iter_from_string(model, &iter, path))
{
... |
functions | int menuitem_manage_quick_presets_sort(gconstpointer a, gconstpointer b)
{
dt_iop_module_so_t *ma = (dt_iop_module_so_t *)a;
dt_iop_module_so_t *mb = (dt_iop_module_so_t *)b;
gchar *s1 = g_utf8_normalize(ma->name(), -1, G_NORMALIZE_ALL);
gchar *sa = g_utf8_casefold(s1, -1);
g_free(s1);
s1 = g_utf8_normalize... |
functions | void menuitem_manage_quick_presets(GtkMenuItem *menuitem, gpointer data)
{
sqlite3_stmt *stmt;
GtkWindow *win = GTK_WINDOW(dt_ui_main_window(darktable.gui->ui));
GtkWidget *dialog = gtk_dialog_new_with_buttons(_("manage module layouts"), win,
GTK_DIALOG_DESTROY_WI... |
functions | void dt_gui_favorite_presets_menu_show()
{
sqlite3_stmt *stmt;
GtkMenu *menu = darktable.gui->presets_popup_menu;
if(menu) gtk_widget_destroy(GTK_WIDGET(menu));
darktable.gui->presets_popup_menu = GTK_MENU(gtk_menu_new());
menu = darktable.gui->presets_popup_menu;
const gboolean default_first = dt_conf_get... |
functions | first
if(image)
{
// only matching if filter is on:
int iformat = 0;
if(dt_image_is_rawprepare_supported(image)) iformat |= FOR_RAW;
else iformat |= FOR_LDR;
if(dt_image_is_hdr(image)) iformat |= FOR_HDR;
int excluded = 0;
if(dt_image_monochrome_flags(image)) excluded |= FOR_NOT_MONO;
... |
functions | else if(last_wp != chk_writeprotect)
{
last_wp = chk_writeprotect;
gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());
} |
functions | void dt_gui_presets_popup_menu_show_for_module(dt_iop_module_t *module)
{
dt_gui_presets_popup_menu_show_internal(module->op, module->version(), module->params, module->params_size,
module->blend_params, module, &module->dev->image_storage, NULL,
... |
functions | void dt_gui_presets_update_mml(const char *name, dt_dev_operation_t op, const int32_t version,
const char *maker, const char *model, const char *lens)
{
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2(
dt_database_get(darktable.db),
"UPDATE data.presets"
" SET maker=... |
functions | void dt_gui_presets_update_iso(const char *name, dt_dev_operation_t op, const int32_t version,
const float min, const float max)
{
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2(
dt_database_get(darktable.db),
"UPDATE data.presets"
" SET iso_min=?1, iso_max=?2"
... |
functions | void dt_gui_presets_update_av(const char *name, dt_dev_operation_t op, const int32_t version, const float min,
const float max)
{
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2(
dt_database_get(darktable.db),
"UPDATE data.presets"
" SET aperture_min=?1, aperture_max=... |
functions | void dt_gui_presets_update_tv(const char *name, dt_dev_operation_t op, const int32_t version, const float min,
const float max)
{
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2(
dt_database_get(darktable.db),
"UPDATE data.presets SET exposure_min=?1, exposure_max=?2 WHERE ... |
functions | void dt_gui_presets_update_fl(const char *name, dt_dev_operation_t op, const int32_t version, const float min,
const float max)
{
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),
"UPDATE data.presets"
... |
functions | void dt_gui_presets_update_ldr(const char *name, dt_dev_operation_t op, const int32_t version,
const int ldrflag)
{
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),
"UPDATE data.presets"
" SET fo... |
functions | void dt_gui_presets_update_autoapply(const char *name, dt_dev_operation_t op, const int32_t version,
const int autoapply)
{
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2(
dt_database_get(darktable.db),
"UPDATE data.presets"
" SET autoapply=?1"
" WHERE o... |
functions | void dt_gui_presets_update_filter(const char *name, dt_dev_operation_t op, const int32_t version,
const int filter)
{
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),
"UPDATE data.presets"
" S... |
includes | #include <stdbool.h> |
includes | #include <stdio.h> |
includes | #include <stdlib.h> |
includes | #include <stdbool.h> |
includes | #include <string.h> |
includes | #include <mach-o/dyld.h> |
includes | #include <mach-o/dyld_priv.h> |
includes | #include <dlfcn.h> |
main | int main(int argc, const char* argv[])
{
if ( ! dlopen_preflight("foo.bundle") ) {
FAIL("coreSymbolication-notify foo.bundle should not be loadable");
exit(0);
} |
includes |
#include <stdint.h> |
includes | #include <ctype.h> |
includes |
#include <string/stdstring.h> |
includes | #include <encodings/utf.h> |
functions | void string_remove_all_chars(char *str, char c)
{
char *read_ptr = NULL;
char *write_ptr = NULL;
if (string_is_empty(str))
return;
read_ptr = str;
write_ptr = str;
while (*read_ptr != '\0')
{
*write_ptr = *read_ptr++;
write_ptr += (*write_ptr != c) ? 1 : 0;
} |
functions | void string_replace_all_chars(char *str, char find, char replace)
{
char *str_ptr = str;
if (string_is_empty(str))
return;
while((str_ptr = strchr(str_ptr, find)) != NULL)
*str_ptr++ = replace;
} |
functions | unsigned string_to_unsigned(const char *str)
{
const char *ptr = NULL;
if (string_is_empty(str))
return 0;
for (ptr = str; *ptr != '\0'; ptr++)
{
if (!isdigit(*ptr))
return 0;
} |
functions | unsigned string_hex_to_unsigned(const char *str)
{
const char *hex_str = str;
const char *ptr = NULL;
size_t len;
if (string_is_empty(str))
return 0;
/* Remove leading '0x', if required */
len = strlen(str);
if (len >= 2)
if ((str[0] == '0') &&
((str[1] == 'x') || (str[... |
defines |
#define Map_ENABLE_HANDLES |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.