ERL_NIF_TERM open_calendar(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { ERL_NIF_TERM out; ErlNifBinary tz; cloner* res; UCalendar* cal; UCalendarType type = UCAL_DEFAULT; UErrorCode status = U_ZERO_ERROR; char type_atom[ATOM_LEN], locale[LOCALE_LEN]; tz.size = 0; tz.data = 0; switch (argc) { case 3: if (!enif_get_atom(env, argv[2], (char*) type_atom, ATOM_LEN, ERL_NIF_LATIN1)) return enif_make_badarg(env); type = parserCalendarType((const char *) type_atom); case 2: if (!enif_inspect_binary(env, argv[1], &tz)) return enif_make_badarg(env); case 1: if (!enif_get_atom(env, argv[0], (char*) locale, LOCALE_LEN, ERL_NIF_LATIN1)) return enif_make_badarg(env); break; default: return enif_make_badarg(env); } /* get a calendar type */ cal = ucal_open( (const UChar *) tz.data, (int32_t) tz.size, (const char *) locale, type, &status); CHECK(env, status); res = (cloner*) enif_alloc_resource(calendar_type, sizeof(cloner)); if (calendar_open(cal, res)) { enif_release_resource(res); return enif_make_badarg(env); } out = enif_make_resource(env, res); enif_release_resource(res); /* resource now only owned by "Erlang" */ return out; }
static int bind_cell(ErlNifEnv *env, const ERL_NIF_TERM cell, sqlite3_stmt *stmt, unsigned int i) { int the_int; ErlNifSInt64 the_long_int; double the_double; char the_atom[MAX_ATOM_LENGTH+1]; ErlNifBinary the_blob; int arity; const ERL_NIF_TERM* tuple; if(enif_get_int(env, cell, &the_int)) return sqlite3_bind_int(stmt, i, the_int); if(enif_get_int64(env, cell, &the_long_int)) return sqlite3_bind_int64(stmt, i, the_long_int); if(enif_get_double(env, cell, &the_double)) return sqlite3_bind_double(stmt, i, the_double); if(enif_get_atom(env, cell, the_atom, sizeof(the_atom), ERL_NIF_LATIN1)) { if(strcmp("undefined", the_atom) == 0) { return sqlite3_bind_null(stmt, i); } return sqlite3_bind_text(stmt, i, the_atom, strlen(the_atom), SQLITE_TRANSIENT); } /* Bind as text assume it is utf-8 encoded text */ if(enif_inspect_iolist_as_binary(env, cell, &the_blob)) return sqlite3_bind_text(stmt, i, (char *) the_blob.data, the_blob.size, SQLITE_TRANSIENT); /* Check for blob tuple */ if(enif_get_tuple(env, cell, &arity, &tuple)) { if(arity != 2) return -1; /* length 2! */ if(enif_get_atom(env, tuple[0], the_atom, sizeof(the_atom), ERL_NIF_LATIN1)) { /* its a blob... */ if(0 == strncmp("blob", the_atom, strlen("blob"))) { /* with a iolist as argument */ if(enif_inspect_iolist_as_binary(env, tuple[1], &the_blob)) { /* kaboom... get the blob */ return sqlite3_bind_blob(stmt, i, the_blob.data, the_blob.size, SQLITE_TRANSIENT); } } } } return -1; }
static int do_iterator_options(ErlNifEnv* env, UCollator* col, const ERL_NIF_TERM in, unsigned int& i) { ERL_NIF_TERM out, list; ERL_NIF_TERM* tuple; unsigned int count; UErrorCode status = U_ZERO_ERROR; int32_t len; char value[ATOM_LEN], key[ATOM_LEN]; int parsed_value, parsed_key; i = 0; if (!enif_get_list_length(env, in, &count)) return 0; list = in; while (enif_get_list_cell(env, list, &out, &list)) { if (enif_get_tuple(env, out, &len, (const ERL_NIF_TERM**) &tuple) && (len == 2)) { /* Set an attribute start */ if (!(enif_get_atom(env, tuple[0], (char*) key, ATOM_LEN, ERL_NIF_LATIN1) && enif_get_atom(env, tuple[1], (char*) value, ATOM_LEN, ERL_NIF_LATIN1))) return 0; parsed_key = parseAttrKey(key); parsed_value = parseAttrValue(value); if ((parsed_value == -1) || (parsed_key == -1)) return 0; ucol_setAttribute(col, (UColAttribute) parsed_key, (UColAttributeValue) parsed_value, &status); if (U_FAILURE(status)) return 0; /* Set an attribute end */ } else return 0; } return 1; }
static ERL_NIF_TERM format_error(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { unsigned len; int res; if (!enif_get_atom_length(env, argv[0], &len, ERL_NIF_LATIN1)) return enif_make_badarg(env); char *atom = malloc(len+1); if (!enif_get_atom(env, argv[0], atom, len+1, ERL_NIF_LATIN1)) { free(atom); return enif_make_badarg(env); } if (!strcmp("done", atom)) res = RS_DONE; else if (!strcmp("blocked", atom)) res = RS_BLOCKED; else if (!strcmp("running", atom)) res = RS_RUNNING; else if (!strcmp("test_skipped", atom)) res = RS_TEST_SKIPPED; else if (!strcmp("io_error", atom)) res = RS_IO_ERROR; else if (!strcmp("syntax_error", atom)) res = RS_SYNTAX_ERROR; else if (!strcmp("mem_error", atom)) res = RS_MEM_ERROR; else if (!strcmp("input_ended", atom)) res = RS_INPUT_ENDED; else if (!strcmp("bad_magic", atom)) res = RS_BAD_MAGIC; else if (!strcmp("unimplemented", atom)) res = RS_UNIMPLEMENTED; else if (!strcmp("corrupt", atom)) res = RS_CORRUPT; else if (!strcmp("internal_error", atom)) res = RS_INTERNAL_ERROR; else if (!strcmp("param_error", atom)) res = RS_PARAM_ERROR; else res = -1; free(atom); return enif_make_string(env, rs_strerror(res), ERL_NIF_LATIN1); }
static ERL_NIF_TERM ex_slp_open(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { char *lang; char *ret_code; int isasync; unsigned int term_len; SLPHandle *hslp; SLPEXP SLPError SLPAPI error; if (enif_get_atom_length(env, argv[0], &term_len, ERL_NIF_LATIN1) < 0) { return enif_make_badarg(env); } if (enif_get_atom(env, argv[0], lang, term_len, ERL_NIF_LATIN1) < 0) { return enif_make_badarg(env); } if ( ! enif_get_int(env, argv[1], &isasync)) return enif_make_badarg(env); hslp = enif_alloc_resource(NIF_SLP_HANDLE, sizeof(SLPHandle)); if (hslp == NULL) return enif_make_badarg(env); //error = SLPOpen(lang, isasync > 0 ? SLP_TRUE : SLP_FALSE, hslp); error = SLPOpen(lang, isasync > 0 ? SLP_TRUE : SLP_FALSE, hslp); ERL_NIF_TERM term = enif_make_resource(env, hslp); enif_release_resource(hslp); return enif_make_tuple2(env, enif_make_int(env, error), term); }
/* Get a collator */ ERL_NIF_TERM get_collator(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { ERL_NIF_TERM out; char locale[LOCALE_LEN]; UErrorCode status = U_ZERO_ERROR; UCollator* col; cloner* res; unsigned int index; if ((argc != 2) && (argc != 1)) return enif_make_badarg(env); if (!enif_get_atom(env, argv[0], (char*) locale, LOCALE_LEN, ERL_NIF_LATIN1)) { return enif_make_badarg(env); } col = ucol_open((char *) locale, &status); CHECK(env, status); res = (cloner*) enif_alloc_resource(collator_type, sizeof(cloner)); if (collator_open(col, res)) { enif_release_resource(res); return enif_make_badarg(env); } CHECK_DEST(env, status, enif_release_resource(res); );
static ERL_NIF_TERM nif_get_json(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { gchar *path = get_char_argument(env, &argv[0]); if (!path) return enif_make_badarg(env); gchar include_content_atom[10]; guint content_option = 0; if (argc == 2 && enif_get_atom(env, argv[1], include_content_atom, sizeof(include_content_atom), ERL_NIF_LATIN1)) { if (!g_ascii_strcasecmp(include_content_atom, "true")) content_option = 1; else if (!g_ascii_strcasecmp(include_content_atom, "raw")) content_option = 2; } GString *json_str = gmimex_get_json(path, content_option); g_free(path); if (!json_str) return enif_make_badarg(env); ErlNifBinary result_binary = {0}; enif_alloc_binary(json_str->len, &result_binary); (void)memcpy(result_binary.data, json_str->str, json_str->len); g_string_free(json_str, TRUE); return enif_make_binary(env, &result_binary); }
ERL_NIF_TERM locale_language_tag(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { UErrorCode status = U_ZERO_ERROR; int32_t /*value_len,*/ key_len; char value[LOCALE_LEN], key[LOCALE_LEN]; if (argc != 1) return enif_make_badarg(env); key_len = enif_get_atom(env, argv[0], (char*) key, LOCALE_LEN, ERL_NIF_LATIN1); if (!key_len) { return enif_make_badarg(env); } /*value_len =*/ uloc_toLanguageTag((const char*) key, /* Locale Id */ (char *) value, /* Name */ (int32_t) LOCALE_LEN, FALSE, &status); CHECK(env, status); return enif_make_atom(env, value); }
static ERL_NIF_TERM do_date_get_field(ErlNifEnv* env, UCalendar* cal, const ERL_NIF_TERM field_atom, UErrorCode& status) { char value[ATOM_LEN]; int parsed_value, amount; UCalendarDateFields field; if (!enif_get_atom(env, field_atom, (char*) value, ATOM_LEN, ERL_NIF_LATIN1)) { status = U_ILLEGAL_ARGUMENT_ERROR; return 0; } parsed_value = parseCalendarDateField(value); if (parsed_value == -1) { status = U_ILLEGAL_ARGUMENT_ERROR; return 0; } field = (UCalendarDateFields) parsed_value; amount = (int) ucal_get(cal, field, &status); if (U_FAILURE(status)) return 0; if (field == UCAL_MONTH) amount++; /* month from 0 */ return enif_make_int(env, amount); }
ERL_NIF_TERM case_compare(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { ErlNifBinary in, in2; char locale[LOCALE_LEN]; UErrorCode status = U_ZERO_ERROR; uint32_t options = U_COMPARE_IGNORE_CASE; int32_t res; if (argc != 3) return enif_make_badarg(env); if (!(enif_get_atom(env, argv[0], locale, LOCALE_LEN, ERL_NIF_LATIN1) && enif_inspect_binary(env, argv[1], &in) && enif_inspect_binary(env, argv[2], &in2))) { return enif_make_badarg(env); } /* Is the locale tr? */ if ((locale[0] == 't') && (locale[1] == 'r')) options |= U_FOLD_CASE_EXCLUDE_SPECIAL_I; /*res = u_strCaseCompare(*/ res = unorm_compare( (const UChar *) in.data, TO_ULEN(in.size), (const UChar *) in2.data, TO_ULEN(in2.size), options, &status); CHECK(env, status); return compare_result_to_atom(env, res); }
jsval to_js_special(ErlNifEnv* env, JSContext* cx, ERL_NIF_TERM term) { JSString* str = NULL; char atom[512]; // Pretty sure there's a 256 byte limit if(!enif_get_atom(env, term, atom, 512, ERL_NIF_LATIN1)) { return JSVAL_VOID; } else if(strcmp(atom, "true") == 0) { return JSVAL_TRUE; } else if(strcmp(atom, "false") == 0) { return JSVAL_FALSE; } else if(strcmp(atom, "null") == 0) { return JSVAL_NULL; } else { str = JS_NewStringCopyZ(cx, atom); if(str == NULL) return JSVAL_VOID; return STRING_TO_JSVAL(str); } }
static inline int match_atom(ErlNifEnv* env, ERL_NIF_TERM term, State *st){ if(!enif_is_atom(env, term)){ return 0; } if(enif_is_identical(term, st->priv->am_true)){ b_puts(4, "true", st); return 1; }else if(enif_is_identical(term, st->priv->am_false)){ b_puts(5, "false", st); return 1; }else if(enif_is_identical(term, st->priv->am_null)){ b_puts(4, "null", st); return 1; } unsigned len, reserve; b_reserve(256 + 2, st); unsigned char *p = st->cur; if((len = enif_get_atom(env, term, (char*)p + 1, 256U, ERL_NIF_LATIN1))){ *p = '"'; if(!check_str_for_json((unsigned char*)p + 1, len-1, &reserve)){ return 0; } if(reserve > 0){ b_reserve(len + reserve + 2, st); extend_str_to_jstr((unsigned char*)p + 1, len-1, reserve); } st->cur += (len + reserve); b_putc('"', st); return 1; } return 0; }
int notify_hints_type(ErlNifEnv *env, NotifyNotification *notify, int arity, ERL_NIF_TERM key, ERL_NIF_TERM value) { char a_key[256] = {0}; union { ErlNifBinary b; int i; double d; } val; const ERL_NIF_TERM *byte = NULL; char a_byte[256] = {0}; int len = 0; if (!enif_get_atom(env, key, a_key, sizeof(a_key), ERL_NIF_LATIN1)) return -1; if (enif_get_int(env, value, &val.i)) notify_notification_set_hint_int32(notify, a_key, val.i); else if (enif_get_double(env, value, &val.d)) notify_notification_set_hint_double(notify, a_key, val.d); else if (enif_get_tuple(env, value, &len, &byte)) { if (len != 2 || !enif_get_atom(env, byte[0], a_byte, sizeof(a_byte), ERL_NIF_LATIN1) || (strcmp(a_byte, "byte") != 0) || !enif_get_int(env, byte[1], &val.i)) return -1; notify_notification_set_hint_byte(notify, a_key, (u_int8_t)val.i); } else if (arity == 0 || enif_inspect_iolist_as_binary(env, value, &val.b)) { gchar *tmpstr = NULL; if (arity > 0) tmpstr = stralloc(&val.b); notify_notification_set_hint_string(notify, a_key, (arity > 0 ? "" : tmpstr)); strfree(tmpstr); } else return -1; return 0; }
inline static ERL_NIF_TERM do_offset(ErlNifEnv* env, UCalendar* cal, date_fun_ptr fun, const ERL_NIF_TERM in) { UCalendarDateFields field; UErrorCode status = U_ZERO_ERROR; ERL_NIF_TERM head, tail; ERL_NIF_TERM* tuple; unsigned int count, i; int32_t len, offset; char value[ATOM_LEN]; int parsed_value; i = 0; if (!enif_get_list_length(env, in, &count)) return enif_make_badarg(env); tail = in; while (enif_get_list_cell(env, tail, &head, &tail)) { if (enif_get_tuple(env, head, &len, (const ERL_NIF_TERM**) &tuple) && (len == 2)) { /* Set an attribute start */ if (!(enif_get_atom(env, tuple[0], (char*) value, ATOM_LEN, ERL_NIF_LATIN1) && enif_get_int(env, tuple[1], &offset))) goto bad_elem; parsed_value = parseCalendarDateField(value); if ((parsed_value == -1)) goto bad_elem; field = (UCalendarDateFields) parsed_value; fun(cal, field, offset, &status); if (U_FAILURE(status)) goto bad_elem; /* Set an attribute end */ } else goto bad_elem; } return calendar_to_double(env, (const UCalendar*) cal); bad_elem: return list_element_error(env, in, i); }
ERL_NIF_TERM date_clear(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { UErrorCode status = U_ZERO_ERROR; UCalendar* cal; cloner* ptr; double date; UCalendarDateFields field; ERL_NIF_TERM head, tail; unsigned int count, i = 0; char value[ATOM_LEN]; int parsed_value; if(!((argc == 3) && enif_get_resource(env, argv[0], calendar_type, (void**) &ptr) && enif_get_double(env, argv[1], &date) && enif_get_list_length(env, argv[2], &count))) { return enif_make_badarg(env); } cal = (UCalendar*) cloner_get(ptr); CHECK_RES(env, cal); ucal_setMillis(cal, (UDate) date, &status); CHECK(env, status); tail = argv[2]; while (enif_get_list_cell(env, tail, &head, &tail)) { /* Set an attribute start */ if (!enif_get_atom(env, head, (char*) value, ATOM_LEN, ERL_NIF_LATIN1)) goto bad_elem; parsed_value = parseCalendarDateField(value); if ((parsed_value == -1)) goto bad_elem; field = (UCalendarDateFields) parsed_value; ucal_clearField(cal, field); if (U_FAILURE(status)) goto bad_elem; /* Set an attribute end */ } return calendar_to_double(env, (const UCalendar*) cal); bad_elem: return list_element_error(env, argv[2], i); }
/* Get a transliterator */ ERL_NIF_TERM get_transliterator(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { ERL_NIF_TERM out; char id[LOCALE_LEN], dir[ATOM_LEN]; UErrorCode status = U_ZERO_ERROR; UTransliterator* obj; cloner* res; int parsed_dir; if (argc != 2) return enif_make_badarg(env); if (!(enif_get_atom(env, argv[0], (char*) id, LOCALE_LEN, ERL_NIF_LATIN1) && enif_get_atom(env, argv[1], (char*) dir, ATOM_LEN, ERL_NIF_LATIN1) )) { return enif_make_badarg(env); } parsed_dir = parseDir(dir); if ((parsed_dir == -1)) return enif_make_badarg(env); obj = utrans_open((char *) id, (UTransDirection) parsed_dir, NULL, 0, NULL, &status); CHECK(env, status); res = (cloner*) enif_alloc_resource(trans_type, sizeof(cloner)); if (trans_open(obj, res)) { enif_release_resource(res); return enif_make_badarg(env); } out = enif_make_resource(env, res); enif_release_resource(res); /* resource now only owned by "Erlang" */ return out; }
static void *TestCall(void *ptr) { TCall *call = (TCall *)ptr; ERL_NIF_TERM result = ErlangCall(call->env, call->fun, call->args); int length; char *buffer; enif_get_atom_length(call->env, result, &length, ERL_NIF_LATIN1); buffer = (char *)malloc((length + 1) * sizeof(char)); enif_get_atom(call->env, result, buffer, length + 1, ERL_NIF_LATIN1); printf("THIS IS YOUR RESULT(%d)! %s\n", length, buffer); return NULL; }
static ERL_NIF_TERM atom_to_bin(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { ErlNifBinary obin; unsigned size; int n; if (!enif_get_int(env,argv[1],(int*)&size) || !enif_alloc_binary(size,&obin)) { return enif_make_badarg(env); } n = enif_get_atom(env, argv[0], (char*)obin.data, size, ERL_NIF_LATIN1); return enif_make_tuple(env, 2, enif_make_int(env,n), enif_make_binary(env,&obin)); }
/** * Erlang Wrapper for geonum_neighbor */ ERL_NIF_TERM erl_geonum_neighbor(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { long long bin_neighbor[1]; long long geonum; char dir[2]; int dir_val; unsigned int dir_len; if(!enif_get_int64(env, argv[0], &geonum)) { return enif_make_badarg(env); } if(!enif_get_atom_length(env, argv[1], &dir_len, ERL_NIF_LATIN1)) { return enif_make_badarg(env); } if(dir_len > sizeof(dir)) { return enif_make_badarg(env); } if(!enif_get_atom(env, argv[1], dir, sizeof(dir), ERL_NIF_LATIN1)) { return enif_make_badarg(env); } switch (dir[0]) { case 'w': dir_val = 0; break; case 'e': dir_val = 1; break; case 'n': dir_val = 2; break; case 's': dir_val = 3; break; default: return enif_make_badarg(env); } geonum_neighbor(geonum, dir_val, bin_neighbor); return make_ok(env, enif_make_int64(env, bin_neighbor[0])); }
ERL_NIF_TERM to_title(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { ErlNifBinary in, out; int32_t ulen; char locale[LOCALE_LEN]; const char* locptr; cloner* ptr; UBreakIterator* iter; UErrorCode status = U_ZERO_ERROR; if (argc != 2) return enif_make_badarg(env); /* Second argument must be a binary */ if(!enif_inspect_binary(env, argv[1], &in)) { return enif_make_badarg(env); } if (enif_get_atom(env, argv[0], locale, LOCALE_LEN, ERL_NIF_LATIN1)) { /* First element is an atom. */ locptr = (const char*) locale; iter = NULL; } else if (enif_get_resource(env, argv[0], iterator_type, (void**) &ptr)) { /* First element is an iterator. */ iter = (UBreakIterator*) cloner_get(ptr); CHECK_RES(env, iter); /* Iterator contains a locale name. Extract it. */ locptr = ubrk_getLocaleByType((const UBreakIterator*) iter, ULOC_ACTUAL_LOCALE, /* locale type */ &status); CHECK(env, status); } else { return enif_make_badarg(env); } ulen = TO_ULEN(in.size); do_to_title(in, out, ulen, iter, locptr, status); if (status == U_BUFFER_OVERFLOW_ERROR) { do_to_title(in, out, ulen, iter, locptr, status); } CHECK(env, status); return enif_make_binary(env, &out); }
static ERL_NIF_TERM nif_socket_protocol(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { char buf[256] = {0}; const struct procket_define *p = NULL; if (!enif_get_atom(env, argv[0], buf, sizeof(buf), ERL_NIF_LATIN1)) return enif_make_badarg(env); for (p = procket_socket_protocol; p->key != NULL; p++) { if (!strcmp(buf, p->key)) return enif_make_int(env, p->val); } return atom_undefined; }
int decode_command_call_into_process(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[], process_t **ptr) { // Instantiate a new process if (pm_new_process(ptr)) return -1; process_t *process = *ptr; const ERL_NIF_TERM* big_tuple; int arity = 2; // Get the outer tuple if(!enif_get_tuple(env, argv[0], &arity, &big_tuple)) return -1; // The first command is a string char command[MAX_BUFFER_SZ], key[MAX_BUFFER_SZ], value[MAX_BUFFER_SZ]; memset(&command, '\0', sizeof(command)); // Get the command if (enif_get_string(env, big_tuple[0], command, sizeof(command), ERL_NIF_LATIN1) < 0) return -1; pm_malloc_and_set_attribute(&process->command, command); // The second element of the tuple is a list of options const ERL_NIF_TERM* tuple; ERL_NIF_TERM head, tail, list = big_tuple[1]; // int enif_get_tuple(ErlNifEnv* env, ERL_NIF_TERM term, int* arity, const ERL_NIF_TERM** array) while(enif_get_list_cell(env, list, &head, &tail)) { // Get the tuple if(!enif_get_tuple(env, head, &arity, &tuple)) return -1; // First element is an atom if (!enif_get_atom(env, tuple[0], key, sizeof(key))) return -2; if (enif_get_string(env, tuple[1], value, sizeof(value), ERL_NIF_LATIN1) < 0) return -3; if (!strcmp(key, "do_before")) { // Do before pm_malloc_and_set_attribute(&process->before, value); } else if (!strcmp(key, "do_after")) { pm_malloc_and_set_attribute(&process->after, value); } else if (!strcmp(key, "cd")) { pm_malloc_and_set_attribute(&process->cd, value); } else if (!strcmp(key, "env")) { pm_add_env(&process, value); } else if (!strcmp(key, "nice")) { process->nice = atoi(value); } list = tail; } return 0; }
static int exmagick_get_boolean_u (ErlNifEnv *env, ERL_NIF_TERM arg, unsigned int *p) { int ecode; char atom[EXM_MAX_ATOM_SIZE]; if (0 != (ecode = enif_get_atom(env, arg, atom, EXM_MAX_ATOM_SIZE, ERL_NIF_LATIN1))) { if (strcmp("true", atom) == 0) { *p = 1; } else if (strcmp("false", atom) == 0) { *p = 0; } else { ecode = 0; } } return(ecode); }
static int atom_to_string(ErlNifEnv* env, ERL_NIF_TERM atom_term, char **bin_str) { unsigned atom_len; char *atom_string; *bin_str = NULL; if(!enif_is_atom(env, atom_term) || !enif_get_atom_length(env, atom_term, &atom_len, ERL_NIF_LATIN1)) return 0; if(!(atom_string = (char*)malloc(atom_len+1))) return 0; if(!enif_get_atom(env, atom_term, atom_string, atom_len+1, ERL_NIF_LATIN1)){ free(atom_string); return 0; } *bin_str = atom_string; return 1; }
ERL_NIF_TERM date_diff_field(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { UErrorCode status = U_ZERO_ERROR; UCalendar* cal; cloner* ptr; double startMs, targetMs; char value[ATOM_LEN]; int parsed_value, amount; UCalendarDateFields field; if(!((argc == 4) && enif_get_resource(env, argv[0], calendar_type, (void**) &ptr) && enif_get_double(env, argv[1], &startMs) && enif_get_double(env, argv[2], &targetMs) && enif_get_atom(env, argv[3], (char*) value, ATOM_LEN, ERL_NIF_LATIN1))) { return enif_make_badarg(env); } cal = (UCalendar*) cloner_get(ptr); CHECK_RES(env, cal); ucal_setMillis(cal, (UDate) startMs, &status); CHECK(env, status); parsed_value = parseCalendarDateField(value); if (parsed_value == -1) { status = U_ILLEGAL_ARGUMENT_ERROR; CHECK(env, status); } field = (UCalendarDateFields) parsed_value; amount = (int) dateFieldDifference(cal, targetMs, field, status); CHECK(env, status); return enif_make_int(env, amount); }
static ERL_NIF_TERM nif_constant(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { char buf[255] = {0}; const struct SERCTL_DEF *p = NULL; if (enif_get_atom(env, argv[0], buf, sizeof(buf), ERL_NIF_LATIN1) < 1) return enif_make_badarg(env); for (p = serctl_const; p->key != NULL; p++) { if (!strcmp(buf, p->key)) return enif_make_uint(env, p->val); } return atom_undefined; }
ERL_NIF_TERM exmagick_get_attr (ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { char atom[EXM_MAX_ATOM_SIZE]; exm_resource_t *resource; EXM_INIT; ErlNifResourceType *type = (ErlNifResourceType *) enif_priv_data(env); if (0 == enif_get_resource(env, argv[0], type, (void **) &resource)) { EXM_FAIL(ehandler, "invalid handle"); } if (0 == enif_get_atom(env, argv[1], atom, EXM_MAX_ATOM_SIZE, ERL_NIF_LATIN1)) { EXM_FAIL(ehandler, "invalid attribute"); } if (strcmp("adjoin", atom) == 0) { if (resource->i_info->adjoin == 0) { return(enif_make_tuple2(env, enif_make_atom(env, "ok"), enif_make_atom(env, "false"))); } else if (resource->i_info->adjoin == 1) { return(enif_make_tuple2(env, enif_make_atom(env, "ok"), enif_make_atom(env, "true"))); } } if (strcmp("rows", atom) == 0) { if (resource->image == NULL) { EXM_FAIL(ehandler, "image not loaded"); } { return(enif_make_tuple2(env, enif_make_atom(env, "ok"), enif_make_long(env, resource->image->rows))); } } if (strcmp("columns", atom) == 0) { if (resource->image == NULL) { EXM_FAIL(ehandler, "image not loaded"); } { return(enif_make_tuple2(env, enif_make_atom(env, "ok"), enif_make_long(env, resource->image->columns))); } } if (strcmp("density", atom) == 0) { return(enif_make_tuple2(env, enif_make_atom(env, "ok"), exmagick_make_utf8str(env, resource->i_info->density))); } else if (strcmp("magick", atom) == 0) { return(enif_make_tuple2(env, enif_make_atom(env, "ok"), exmagick_make_utf8str(env, resource->image->magick))); } ehandler: return(enif_make_tuple2(env, enif_make_atom(env, "error"), exmagick_make_utf8str(env, errmsg))); }
static ERL_NIF_TERM exmagick_set_attr (ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { ErlNifBinary utf8; char atom[EXM_MAX_ATOM_SIZE]; exm_resource_t *resource; EXM_INIT; ErlNifResourceType *type = (ErlNifResourceType *) enif_priv_data(env); if (0 == enif_get_resource(env, argv[0], type, (void **) &resource)) { EXM_FAIL(ehandler, "invalid handle"); } if (0 == enif_get_atom(env, argv[1], atom, EXM_MAX_ATOM_SIZE, ERL_NIF_LATIN1)) { EXM_FAIL(ehandler, "argv[1]: bad argument"); } if (strcmp("adjoin", atom) == 0) { if (0 == exmagick_get_boolean_u(env, argv[2], &resource->i_info->adjoin)) { EXM_FAIL(ehandler, "argv[2]: bad argument"); } } if (strcmp("magick", atom) == 0) { if (0 == exmagick_get_utf8str(env, argv[2], &utf8)) { EXM_FAIL(ehandler, "argv[2]: bad argument"); } exmagick_utf8strcpy(resource->image->magick, &utf8, MaxTextExtent); } if (strcmp("density", atom) == 0) { if (0 == exmagick_get_utf8str(env, argv[2], &utf8)) { EXM_FAIL(ehandler, "argv[2]: bad argument"); } MagickFree(resource->i_info->density); resource->i_info->density=exmagick_utf8strdup(&utf8); if (resource->i_info->density == NULL) { EXM_FAIL(ehandler, "could not set density"); } } return(enif_make_tuple2(env, enif_make_atom(env, "ok"), argv[0])); ehandler: return(enif_make_tuple2(env, enif_make_atom(env, "error"), exmagick_make_utf8str(env, errmsg))); }
static inline int match_atom_as_string(ErlNifEnv* env, ERL_NIF_TERM term, State *st){ unsigned len, reserve; b_reserve(256 + 2, st); unsigned char *p = st->cur; if((len = enif_get_atom(env, term, (char*)p + 1, 256U, ERL_NIF_LATIN1))){ *p = '"'; if(!check_str_for_json((unsigned char*)p + 1, len-1, &reserve)){ return 0; } if(reserve > 0){ b_reserve(len + reserve + 2, st); extend_str_to_jstr((unsigned char*)p + 1, len-1, reserve); } st->cur += (len + reserve); b_putc('"', st); return 1; } return 0; }
// Creates a new property list as an instance of a property list class. ERL_NIF_TERM h5pcreate(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { hid_t dcpl_id; // dataset creation property list Handle* res; ERL_NIF_TERM ret; unsigned cls_id; char cls[MAXBUFLEN]; // parse arguments check(argc == 1, "Incorrent number of arguments"); check(enif_get_atom(env, argv[0], cls, sizeof(cls), ERL_NIF_LATIN1) != 0, \ "Can't get class id from argv"); // convert access flag to format which hdf5 api understand check(convert_property_flag(cls, &cls_id) == 0, "Failed to convert access flag"); // create a new file using default properties dcpl_id = H5Pcreate(cls_id); check(dcpl_id > 0, "Failed to create property list."); // create a resource to pass reference to id back to erlang res = enif_alloc_resource(RES_TYPE, sizeof(Handle)); check(res, "Failed to allocate resource for type %s", "Handle"); // add ref to resource res->id = dcpl_id; ret = enif_make_resource(env, res); // cleanup enif_release_resource(res); return enif_make_tuple2(env, ATOM_OK, ret); error: if(dcpl_id) H5Pclose(dcpl_id); return error_tuple(env, "Can not create properties list"); };