static bool
read_verb(SerdReader* reader, Ref* dest)
{
if (peek_byte(reader) == '<') {
return (*dest = read_IRIREF(reader));
} else {
/* Either a qname, or "a". Read the prefix first, and if it is in fact
"a", produce that instead.
*/
*dest = push_node(reader, SERD_CURIE, "", 0);
SerdNode* node = deref(reader, *dest);
const SerdStatus st = read_PN_PREFIX(reader, *dest);
bool ate_dot = false;
if (!st && node->n_bytes == 1 && node->buf[0] == 'a' &&
is_token_end(peek_byte(reader))) {
pop_node(reader, *dest);
return (*dest = push_node(reader, SERD_URI, NS_RDF "type", 47));
} else if (st > SERD_FAILURE ||
!read_PrefixedName(reader, *dest, false, &ate_dot) ||
ate_dot) {
return (*dest = pop_node(reader, *dest));
} else {
return true;
}
}
return false;
}
int main()
{
int result =0;
node* a = NULL;
//Created lists, a: 1->3->15,
push_node(&a, 9);
push_node(&a, 8);
push_node(&a, 7);
push_node(&a, 6);
push_node(&a, 5);
push_node(&a, 4);
push_node(&a, 3);
push_node(&a, 2);
push_node(&a, 1);
node *temp = a->next->next->next;
node *last = a;
while(last->next != NULL)
last = last->next;
last->next = temp;
result = ReturnBeginingOfLoop(a);
printf("%d", result);
return 0;
}
void main(){
struct node* head=NULL;
push_node(&head, 1);
push_node(&head, 2);
push_node(&head, 3);
push_node(&head, 4);
push_node(&head, 5);
print_list(head);
printf("\nMiddle element is %d: ", middle(head)->data);
}
static void
build_graph(struct lattice_info* info, int from, int to)
{
int i;
struct lattice_node* node;
struct lattice_node* left_node;
/* 始点となるノードを追加 */
node = alloc_lattice_node(info, NULL, NULL, from);
push_node(info, node, from);
/* info->lattice_node_list[index]にはindexまでの遷移が入っているのであって、
* indexからの遷移が入っているのではない
*/
/* 全ての遷移を左から試す */
for (i = from; i < to; ++i) {
for (left_node = info->lattice_node_list[i].head; left_node;
left_node = left_node->next) {
struct meta_word *mw;
/* i文字目に到達するlattice_nodeのループ */
for (mw = info->sc->word_split_info->cnode[i].mw; mw; mw = mw->next) {
int position;
struct lattice_node* new_node;
/* i文字目からのmeta_wordのループ */
if (mw->can_use != ok) {
continue; /* 決められた文節の区切りをまたぐmetawordは使わない */
}
position = i + mw->len;
new_node = alloc_lattice_node(info, left_node, mw, i);
push_node(info, new_node, position);
/* 解の候補が多すぎたら、確率の低い方から削る */
if (info->lattice_node_list[position].nr_nodes >= NODE_MAX_SIZE) {
remove_min_node(info, &info->lattice_node_list[position]);
}
}
}
}
/* 文末補正 */
for (node = info->lattice_node_list[to].head; node; node = node->next) {
struct feature_list features;
anthy_feature_list_init(&features);
build_feature_list(NULL, &features);
node->adjusted_probability = node->adjusted_probability *
calc_probability(SEG_TAIL, &features);
anthy_feature_list_free(&features);
}
}
static void add_children(lua_State *L, const GumboVector *children) {
const unsigned int length = children->length;
for (unsigned int i = 0; i < length; i++) {
push_node(L, (const GumboNode *)children->data[i]);
lua_rawseti(L, -2, i + 1);
}
}
static bool
read_prefixID(SerdReader* reader)
{
bool ret = true;
// `@' is already eaten in read_directive
eat_string(reader, "prefix", 6);
TRY_RET(read_ws_plus(reader));
Ref name = push_node(reader, SERD_LITERAL, "", 0);
if (read_PN_PREFIX(reader, name) > SERD_FAILURE) {
return pop_node(reader, name);
}
if (eat_byte_check(reader, ':') != ':') {
return pop_node(reader, name);
}
read_ws_star(reader);
const Ref uri = read_IRIREF(reader);
if (!uri) {
pop_node(reader, name);
return false;
}
if (reader->prefix_sink) {
ret = !reader->prefix_sink(reader->handle,
deref(reader, name),
deref(reader, uri));
}
pop_node(reader, uri);
pop_node(reader, name);
return ret;
}
int main(){
NODE *ptr = NULL;
int ch;
while(1){
printf("choose stack function <1>push <2>pop <3>show all nodes :");
scanf("%d",&ch);
switch(ch){
case 1:
ptr = push_node(ptr);
//printf("ptr->data:%d ptr->next:%p\n",ptr->data,ptr->nextpoint);
break;
case 2:
ptr = pop_node(ptr);
break;
case 3:
show_node(ptr);
break;
default:
printf("wrong input,try again\n");
}
}
system("pause");
return(0);
}
// STRING_LITERAL_QUOTE and STRING_LITERAL_SINGLE_QUOTE
// Initial quote is already eaten by caller
static Ref
read_STRING_LITERAL(SerdReader* reader, SerdNodeFlags* flags, uint8_t q)
{
Ref ref = push_node(reader, SERD_LITERAL, "", 0);
while (true) {
const uint8_t c = peek_byte(reader);
uint32_t code;
switch (c) {
case '\n': case '\r':
r_err(reader, SERD_ERR_BAD_SYNTAX, "line end in short string\n");
return pop_node(reader, ref);
case '\\':
eat_byte_safe(reader, c);
if (!read_ECHAR(reader, ref, flags) &&
!read_UCHAR(reader, ref, &code)) {
r_err(reader, SERD_ERR_BAD_SYNTAX,
"invalid escape `\\%c'\n", peek_byte(reader));
return pop_node(reader, ref);
}
break;
default:
if (c == q) {
eat_byte_check(reader, q);
return ref;
} else {
read_character(reader, ref, flags, eat_byte_safe(reader, c));
}
}
}
eat_byte_check(reader, q);
return ref;
}
SERD_API
SerdReader*
serd_reader_new(SerdSyntax syntax,
void* handle,
void (*free_handle)(void*),
SerdBaseSink base_sink,
SerdPrefixSink prefix_sink,
SerdStatementSink statement_sink,
SerdEndSink end_sink)
{
const Cursor cur = { NULL, 0, 0 };
SerdReader* me = (SerdReader*)malloc(sizeof(struct SerdReaderImpl));
me->handle = handle;
me->free_handle = free_handle;
me->base_sink = base_sink;
me->prefix_sink = prefix_sink;
me->statement_sink = statement_sink;
me->end_sink = end_sink;
me->error_sink = NULL;
me->error_handle = NULL;
me->default_graph = SERD_NODE_NULL;
me->fd = 0;
me->stack = serd_stack_new(SERD_PAGE_SIZE);
me->syntax = syntax;
me->cur = cur;
me->bprefix = NULL;
me->bprefix_len = 0;
me->next_id = 1;
me->read_buf = 0;
me->file_buf = 0;
me->read_head = 0;
me->strict = false;
me->eof = false;
me->seen_genid = false;
#ifdef SERD_STACK_CHECK
me->allocs = 0;
me->n_allocs = 0;
#endif
me->rdf_first = push_node(me, SERD_URI, NS_RDF "first", 48);
me->rdf_rest = push_node(me, SERD_URI, NS_RDF "rest", 47);
me->rdf_nil = push_node(me, SERD_URI, NS_RDF "nil", 46);
return me;
}
static void
kill_unit (Unit *u){
Node *n = extruct_node(&units, data2node(units, u));
push_node(&dead_units, n);
if(u == selected_unit)
selected_unit = NULL;
else
fill_map(selected_unit);
}
int main()
{
int i, j, k, x, y, ncase;
int v[105];
scanf("%d", &ncase);
while (ncase-- > 0)
{
memset(graph, 0, sizeof(graph));
scanf("%d%d", &n, &k);
for(i = 0; i < k; i++)
{
scanf("%d%d", &x, &y);
push_node(graph[x], y);
push_node(graph[y], x);
}
max = 0;
memset(v, 0, sizeof(v));
dfs(0, v, 0, n);
printf("%d\n", max);
for(i = 1; i <= n; i++)
{
if ( !ans[i][101] )
{
printf("%d", i);
break;
}
}
++i;
while (i <= n )
{
if (!ans[i][101])
printf(" %d", i);
++i;
}
puts("");
}
}
static void
set_children(lua_State *L, const GumboVector *vec, unsigned int start) {
const unsigned int length = vec->length;
lua_createtable(L, length, 0);
setmetatable(L, NodeList);
for (unsigned int i = 0; i < length; i++) {
push_node(L, (const GumboNode *)vec->data[i]);
set_value(L, "parentNode", -3); // child.parentNode = parent
lua_rawseti(L, -2, i + start); // parent.childNodes[i+start] = child
}
lua_setfield(L, -2, "childNodes");
}
__inline_call bool_type push_node (
real_type *_ppos,
iptr_type &_node,
iptr_type _hint = null_flag()
)
{
bool_type _pass = push_node (
_ppos, _node, _hint,
(iptr_list*)nullptr,
(iptr_list*)nullptr,
(iptr_list*)nullptr) ;
return ( _pass ) ;
}
int main(int argc, char **argv) {
struct node *root = NULL;
int i;
int code = -1;
const char *filelist[argc];
if(argc == 1) {
printf("No files to (F)lex!\n");
return 0;
}
/* Put file names in list */
argc--;
argv++;
for (i = 0; i < argc; i++) {
filelist[i] = argv[i];
}
/* Push onto flex's convenient buffer */
for (i = 0; i < argc; i++) {
// yyin = fopen(filelist[i],"r");
yyin = fopen(argv[i],"r");
if (yyin == NULL) {
printf("%s is not a file!\n",filelist[i]);
return 0;
}
/* Push onto filestack as defined in token.c */
push_node(&filestack, filelist[i]);
yypush_buffer_state(yy_create_buffer(yyin, YY_BUF_SIZE));
}
printf("FILES TO BE PARSED:\n");
print_stack(&filestack);
int parse_code = 0;
while(!feof(yyin)) {
parse_code = yyparse();
}
printf("Result: %d\n", parse_code);
// printf("%s\n",yylval.tptr->name);
treeprint(t_unit, 0);
return 0;
}
static bool
read_iri(SerdReader* reader, Ref* dest, bool* ate_dot)
{
switch (peek_byte(reader)) {
case '<':
*dest = read_IRIREF(reader);
break;
default:
*dest = push_node(reader, SERD_CURIE, "", 0);
if (!read_PrefixedName(reader, *dest, true, ate_dot)) {
*dest = pop_node(reader, *dest);
}
}
return *dest != 0;
}
static Ref
read_IRIREF(SerdReader* reader)
{
TRY_RET(eat_byte_check(reader, '<'));
Ref ref = push_node(reader, SERD_URI, "", 0);
uint32_t code;
while (true) {
const uint8_t c = peek_byte(reader);
switch (c) {
case '"': case '<': case '^': case '`': case '{': case '|': case '}':
r_err(reader, SERD_ERR_BAD_SYNTAX,
"invalid IRI character `%c'\n", c);
return pop_node(reader, ref);
case '>':
eat_byte_safe(reader, c);
return ref;
case '\\':
eat_byte_safe(reader, c);
if (!read_UCHAR(reader, ref, &code)) {
r_err(reader, SERD_ERR_BAD_SYNTAX, "invalid IRI escape\n");
return pop_node(reader, ref);
}
switch (code) {
case 0: case ' ': case '<': case '>':
r_err(reader, SERD_ERR_BAD_SYNTAX,
"invalid escaped IRI character %X %c\n", code, code);
return pop_node(reader, ref);
}
break;
default:
if (c <= 0x20) {
if (isprint(c)) {
r_err(reader, SERD_ERR_BAD_SYNTAX,
"invalid IRI character `%c' (escape %%%02X)\n", c, c);
} else {
r_err(reader, SERD_ERR_BAD_SYNTAX,
"invalid IRI character (escape %%%02X)\n", c, c);
}
if (reader->strict) {
return pop_node(reader, ref);
}
push_byte(reader, ref, eat_byte_safe(reader, c));
} else {
push_byte(reader, ref, eat_byte_safe(reader, c));
}
}
}
}
static Ref
read_BLANK_NODE_LABEL(SerdReader* reader, bool* ate_dot)
{
eat_byte_safe(reader, '_');
eat_byte_check(reader, ':');
Ref ref = push_node(reader, SERD_BLANK,
reader->bprefix ? (char*)reader->bprefix : "",
reader->bprefix_len);
uint8_t c = peek_byte(reader); // First: (PN_CHARS | '_' | [0-9])
if (is_digit(c) || c == '_') {
push_byte(reader, ref, eat_byte_safe(reader, c));
} else if (!read_PN_CHARS(reader, ref)) {
r_err(reader, SERD_ERR_BAD_SYNTAX, "invalid name start character\n");
return pop_node(reader, ref);
}
while ((c = peek_byte(reader))) { // Middle: (PN_CHARS | '.')*
if (c == '.') {
push_byte(reader, ref, eat_byte_safe(reader, c));
} else if (!read_PN_CHARS(reader, ref)) {
break;
}
}
SerdNode* n = deref(reader, ref);
if (n->buf[n->n_bytes - 1] == '.' && !read_PN_CHARS(reader, ref)) {
// Ate trailing dot, pop it from stack/node and inform caller
--n->n_bytes;
serd_stack_pop(&reader->stack, 1);
*ate_dot = true;
}
if (reader->syntax == SERD_TURTLE) {
if (is_digit(n->buf[reader->bprefix_len + 1])) {
if ((n->buf[reader->bprefix_len]) == 'b') {
((char*)n->buf)[reader->bprefix_len] = 'B'; // Prevent clash
reader->seen_genid = true;
} else if (reader->seen_genid &&
n->buf[reader->bprefix_len] == 'B') {
r_err(reader, SERD_ERR_ID_CLASH,
"found both `b' and `B' blank IDs, prefix required\n");
return pop_node(reader, ref);
}
}
}
return ref;
}
void sorted_insert (struct node **list, struct node *node)
// Insert the given node into the given list in alphabetical order according
// to input_string[node -> starti].
{
struct node **curr = list;
if (input_string[node -> starti] == '$') { // put $ at the end of list
while (*curr) {
curr = &((*curr) -> rightsib);
}
} else {
while (*curr && input_string[(*curr) -> starti] < input_string[node -> starti]) {
curr = &((*curr) -> rightsib);
}
}
push_node (curr, node);
}
/** Push object into the queue by moving it.
*
* @param t Object you want to push into the queue. Requires T to be
* MoveConstructible.
* @throws Any exceptions thrown by the move constructor of the object.
*
* @note This function is Thread-safe, lock-free and wait-free.
*/
void push_back(T&& t)
{
auto new_node = NodeAllocatorTraits::allocate(alc_, 1);
try {
ValueAllocator alc(alc_);
ValueAllocatorTraits::construct(
alc, &new_node->t, std::move(t)
);
} catch(...)
{
NodeAllocatorTraits::deallocate(alc_, new_node, 1);
throw;
}
new_node->next = nullptr;
push_node(new_node);
}
void emplace_back(Args&&... args)
{
auto new_node = NodeAllocatorTraits::allocate(alc_, 1);
try {
ValueAllocator alc(alc_);
ValueAllocatorTraits::construct(
alc, &new_node->t, std::forward<Args>(args)...
);
} catch(...)
{
NodeAllocatorTraits::deallocate(alc_, new_node, 1);
throw;
}
new_node->next = nullptr;
push_node(new_node);
}
static int parse(lua_State *L) {
size_t length;
const char *input = luaL_checklstring(L, 1, &length);
GumboOptions options = kGumboDefaultOptions;
options.tab_stop = luaL_optint(L, 2, 8);
GumboOutput *output = gumbo_parse_with_options(&options, input, length);
if (output) {
push_node(L, output->document);
lua_rawgeti(L, -1, output->root->index_within_parent + 1);
lua_setfield(L, -2, "root");
gumbo_destroy_output(&options, output);
return 1;
} else {
lua_pushnil(L);
lua_pushliteral(L, "Failed to parse");
return 2;
}
}
static Ref
read_String(SerdReader* reader, SerdNodeFlags* flags)
{
const uint8_t q1 = peek_byte(reader);
eat_byte_safe(reader, q1);
const uint8_t q2 = peek_byte(reader);
if (q2 != q1) { // Short string (not triple quoted)
return read_STRING_LITERAL(reader, flags, q1);
}
eat_byte_safe(reader, q2);
const uint8_t q3 = peek_byte(reader);
if (q3 != q1) { // Empty short string ("" or '')
return push_node(reader, SERD_LITERAL, "", 0);
}
eat_byte_safe(reader, q3);
return read_STRING_LITERAL_LONG(reader, flags, q1);
}
static Ref
read_LANGTAG(SerdReader* reader)
{
uint8_t c = peek_byte(reader);
if (!is_alpha(c)) {
return r_err(reader, SERD_ERR_BAD_SYNTAX, "unexpected `%c'\n", c);
}
Ref ref = push_node(reader, SERD_LITERAL, "", 0);
push_byte(reader, ref, eat_byte_safe(reader, c));
while ((c = peek_byte(reader)) && is_alpha(c)) {
push_byte(reader, ref, eat_byte_safe(reader, c));
}
while (peek_byte(reader) == '-') {
push_byte(reader, ref, eat_byte_safe(reader, '-'));
while ((c = peek_byte(reader)) && (is_alpha(c) || is_digit(c))) {
push_byte(reader, ref, eat_byte_safe(reader, c));
}
}
return ref;
}
t_lst *init_lst(char **env)
{
t_lst *node;
t_lst *head;
head = NULL;
while (*env)
{
node = (t_lst *)malloc(sizeof(t_lst));
if (!node)
return (NULL);
node->next = NULL;
node->line = ft_strdup(*env);
node->name = ft_strsub(*env, 0, ft_strlen_char(*env, '='));
if (ft_strccmp(*env, "USER="******"HOME=", 5) == 0)
node->home = ft_strchr(*env, '/');
push_node(node, &head);
env++;
}
return (head);
}
// STRING_LITERAL_LONG_QUOTE and STRING_LITERAL_LONG_SINGLE_QUOTE
// Initial triple quotes are already eaten by caller
static Ref
read_STRING_LITERAL_LONG(SerdReader* reader, SerdNodeFlags* flags, uint8_t q)
{
Ref ref = push_node(reader, SERD_LITERAL, "", 0);
while (true) {
const uint8_t c = peek_byte(reader);
uint32_t code;
switch (c) {
case '\\':
eat_byte_safe(reader, c);
if (!read_ECHAR(reader, ref, flags) &&
!read_UCHAR(reader, ref, &code)) {
r_err(reader, SERD_ERR_BAD_SYNTAX,
"invalid escape `\\%c'\n", peek_byte(reader));
return pop_node(reader, ref);
}
break;
default:
if (c == q) {
eat_byte_safe(reader, q);
const uint8_t q2 = eat_byte_safe(reader, peek_byte(reader));
const uint8_t q3 = peek_byte(reader);
if (q2 == q && q3 == q) { // End of string
eat_byte_safe(reader, q3);
return ref;
} else {
*flags |= SERD_HAS_QUOTE;
push_byte(reader, ref, c);
read_character(reader, ref, flags, q2);
}
} else {
read_character(reader, ref, flags, eat_byte_safe(reader, c));
}
}
}
return ref;
}
void *brubeck_slab_alloc(struct brubeck_slab *slab, size_t need)
{
struct brubeck_slab_node *node;
void *ptr;
need = ((need + SLAB_SIZE - 1) & ~(SLAB_SIZE - 1));
pthread_mutex_lock(&slab->lock);
node = slab->current;
if (node->alloc + need > NODE_SIZE) {
node = push_node(slab);
}
slab->total_alloc += need;
ptr = node->heap + node->alloc;
node->alloc += need;
pthread_mutex_unlock(&slab->lock);
return ptr;
}
int main()
{
Node* result = NULL;
Node* a = NULL;
Node* b = NULL;
//Created lists, a: 1->3->15, b: 2->3->20
push_node(&a, 15);
push_node(&a, 3);
push_node(&a, 1);
push_node(&b, 20);
push_node(&b, 3);
push_node(&b, 2);
result = merge_sorted_linked_list(a, b);
printf("Merged Linked List: \n");
print_list(result);
return 0;
}
/**
* Tree expansion.
*/
struct mib_node *
snmp_expand_tree(struct mib_node *node, u8_t ident_len, s32_t *ident, struct snmp_obj_id *oidret)
{
u8_t node_type, ext_level, climb_tree;
ext_level = 0;
/* reset node stack */
node_stack_cnt = 0;
while (node != NULL)
{
climb_tree = 0;
node_type = node->node_type;
if ((node_type == MIB_NODE_AR) || (node_type == MIB_NODE_RA))
{
struct mib_array_node *an;
u16_t i;
/* array node (internal ROM or RAM, fixed length) */
an = (struct mib_array_node *)node;
if (ident_len > 0)
{
i = 0;
while ((i < an->maxlength) && (an->objid[i] < *ident))
{
i++;
}
if (i < an->maxlength)
{
LWIP_DEBUGF(SNMP_MIB_DEBUG,("an->objid[%"U16_F"]==%"S32_F" *ident==%"S32_F"\n",i,an->objid[i],*ident));
/* add identifier to oidret */
oidret->id[oidret->len] = an->objid[i];
(oidret->len)++;
if (an->nptr[i] == NULL)
{
LWIP_DEBUGF(SNMP_MIB_DEBUG,("leaf node\n"));
/* leaf node (e.g. in a fixed size table) */
if (an->objid[i] > *ident)
{
return (struct mib_node*)an;
}
else if ((i + 1) < an->maxlength)
{
/* an->objid[i] == *ident */
(oidret->len)--;
oidret->id[oidret->len] = an->objid[i + 1];
(oidret->len)++;
return (struct mib_node*)an;
}
else
{
/* (i + 1) == an->maxlength */
(oidret->len)--;
climb_tree = 1;
}
}
else
{
u8_t j;
struct nse cur_node;
LWIP_DEBUGF(SNMP_MIB_DEBUG,("non-leaf node\n"));
/* non-leaf, store right child ptr and id */
LWIP_ASSERT("i < 0xff", i < 0xff);
j = (u8_t)i + 1;
while ((j < an->maxlength) && (empty_table(an->nptr[j])))
{
j++;
}
if (j < an->maxlength)
{
cur_node.r_ptr = an->nptr[j];
cur_node.r_id = an->objid[j];
cur_node.r_nl = 0;
}
else
{
cur_node.r_ptr = NULL;
}
push_node(&cur_node);
if (an->objid[i] == *ident)
{
ident_len--;
ident++;
}
else
{
/* an->objid[i] < *ident */
ident_len = 0;
}
/* follow next child pointer */
node = an->nptr[i];
}
}
else
{
/* i == an->maxlength */
climb_tree = 1;
}
}
else
{
u8_t j;
/* ident_len == 0, complete with leftmost '.thing' */
j = 0;
while ((j < an->maxlength) && empty_table(an->nptr[j]))
{
j++;
}
if (j < an->maxlength)
{
LWIP_DEBUGF(SNMP_MIB_DEBUG,("left an->objid[j]==%"S32_F"\n",an->objid[j]));
oidret->id[oidret->len] = an->objid[j];
(oidret->len)++;
if (an->nptr[j] == NULL)
{
/* leaf node */
return (struct mib_node*)an;
}
else
{
/* no leaf, continue */
node = an->nptr[j];
}
}
else
{
/* j == an->maxlength */
climb_tree = 1;
}
}
}
else if(node_type == MIB_NODE_LR)
{
struct mib_list_rootnode *lrn;
struct mib_list_node *ln;
/* list root node (internal 'RAM', variable length) */
lrn = (struct mib_list_rootnode *)node;
if (ident_len > 0)
{
ln = lrn->head;
/* iterate over list, head to tail */
while ((ln != NULL) && (ln->objid < *ident))
{
ln = ln->next;
}
if (ln != NULL)
{
LWIP_DEBUGF(SNMP_MIB_DEBUG,("ln->objid==%"S32_F" *ident==%"S32_F"\n",ln->objid,*ident));
oidret->id[oidret->len] = ln->objid;
(oidret->len)++;
if (ln->nptr == NULL)
{
/* leaf node */
if (ln->objid > *ident)
{
return (struct mib_node*)lrn;
}
else if (ln->next != NULL)
{
/* ln->objid == *ident */
(oidret->len)--;
oidret->id[oidret->len] = ln->next->objid;
(oidret->len)++;
return (struct mib_node*)lrn;
}
else
{
/* ln->next == NULL */
(oidret->len)--;
climb_tree = 1;
}
}
else
{
struct mib_list_node *jn;
struct nse cur_node;
/* non-leaf, store right child ptr and id */
jn = ln->next;
while ((jn != NULL) && empty_table(jn->nptr))
{
jn = jn->next;
}
if (jn != NULL)
{
cur_node.r_ptr = jn->nptr;
cur_node.r_id = jn->objid;
cur_node.r_nl = 0;
}
else
{
cur_node.r_ptr = NULL;
}
push_node(&cur_node);
if (ln->objid == *ident)
{
ident_len--;
ident++;
}
else
{
/* ln->objid < *ident */
ident_len = 0;
}
/* follow next child pointer */
node = ln->nptr;
}
}
else
{
/* ln == NULL */
climb_tree = 1;
}
}
else
{
struct mib_list_node *jn;
/* ident_len == 0, complete with leftmost '.thing' */
jn = lrn->head;
while ((jn != NULL) && empty_table(jn->nptr))
{
jn = jn->next;
}
if (jn != NULL)
{
LWIP_DEBUGF(SNMP_MIB_DEBUG,("left jn->objid==%"S32_F"\n",jn->objid));
oidret->id[oidret->len] = jn->objid;
(oidret->len)++;
if (jn->nptr == NULL)
{
/* leaf node */
LWIP_DEBUGF(SNMP_MIB_DEBUG,("jn->nptr == NULL\n"));
return (struct mib_node*)lrn;
}
else
{
/* no leaf, continue */
node = jn->nptr;
}
}
else
{
/* jn == NULL */
climb_tree = 1;
}
}
}
else if(node_type == MIB_NODE_EX)
{
struct mib_external_node *en;
s32_t ex_id;
/* external node (addressing and access via functions) */
en = (struct mib_external_node *)node;
if (ident_len > 0)
{
u16_t i, len;
i = 0;
len = en->level_length(en->addr_inf,ext_level);
while ((i < len) && (en->ident_cmp(en->addr_inf,ext_level,i,*ident) < 0))
{
i++;
}
if (i < len)
{
/* add identifier to oidret */
en->get_objid(en->addr_inf,ext_level,i,&ex_id);
LWIP_DEBUGF(SNMP_MIB_DEBUG,("en->objid[%"U16_F"]==%"S32_F" *ident==%"S32_F"\n",i,ex_id,*ident));
oidret->id[oidret->len] = ex_id;
(oidret->len)++;
if ((ext_level + 1) == en->tree_levels)
{
LWIP_DEBUGF(SNMP_MIB_DEBUG,("leaf node\n"));
/* leaf node */
if (ex_id > *ident)
{
return (struct mib_node*)en;
}
else if ((i + 1) < len)
{
/* ex_id == *ident */
en->get_objid(en->addr_inf,ext_level,i + 1,&ex_id);
(oidret->len)--;
oidret->id[oidret->len] = ex_id;
(oidret->len)++;
return (struct mib_node*)en;
}
else
{
/* (i + 1) == len */
(oidret->len)--;
climb_tree = 1;
}
}
else
{
u8_t j;
struct nse cur_node;
LWIP_DEBUGF(SNMP_MIB_DEBUG,("non-leaf node\n"));
/* non-leaf, store right child ptr and id */
LWIP_ASSERT("i < 0xff", i < 0xff);
j = (u8_t)i + 1;
if (j < len)
{
/* right node is the current external node */
cur_node.r_ptr = node;
en->get_objid(en->addr_inf,ext_level,j,&cur_node.r_id);
cur_node.r_nl = ext_level + 1;
}
else
{
cur_node.r_ptr = NULL;
}
push_node(&cur_node);
if (en->ident_cmp(en->addr_inf,ext_level,i,*ident) == 0)
{
ident_len--;
ident++;
}
else
{
/* external id < *ident */
ident_len = 0;
}
/* proceed to child */
ext_level++;
}
}
else
{
/* i == len (en->level_len()) */
climb_tree = 1;
}
}
else
{
/* ident_len == 0, complete with leftmost '.thing' */
en->get_objid(en->addr_inf,ext_level,0,&ex_id);
LWIP_DEBUGF(SNMP_MIB_DEBUG,("left en->objid==%"S32_F"\n",ex_id));
oidret->id[oidret->len] = ex_id;
(oidret->len)++;
if ((ext_level + 1) == en->tree_levels)
{
/* leaf node */
LWIP_DEBUGF(SNMP_MIB_DEBUG,("(ext_level + 1) == en->tree_levels\n"));
return (struct mib_node*)en;
}
else
{
/* no leaf, proceed to child */
ext_level++;
}
}
}
else if(node_type == MIB_NODE_SC)
{
mib_scalar_node *sn;
/* scalar node */
sn = (mib_scalar_node *)node;
if (ident_len > 0)
{
/* at .0 */
climb_tree = 1;
}
else
{
/* ident_len == 0, complete object identifier */
oidret->id[oidret->len] = 0;
(oidret->len)++;
/* leaf node */
LWIP_DEBUGF(SNMP_MIB_DEBUG,("completed scalar leaf\n"));
return (struct mib_node*)sn;
}
}
else
{
/* unknown/unhandled node_type */
LWIP_DEBUGF(SNMP_MIB_DEBUG,("expand failed node_type %"U16_F" unkown\n",(u16_t)node_type));
return NULL;
}
if (climb_tree)
{
struct nse child;
/* find right child ptr */
child.r_ptr = NULL;
child.r_id = 0;
child.r_nl = 0;
while ((node_stack_cnt > 0) && (child.r_ptr == NULL))
{
pop_node(&child);
/* trim returned oid */
(oidret->len)--;
}
if (child.r_ptr != NULL)
{
/* incoming ident is useless beyond this point */
ident_len = 0;
oidret->id[oidret->len] = child.r_id;
oidret->len++;
node = child.r_ptr;
ext_level = child.r_nl;
}
else
{
/* tree ends here ... */
LWIP_DEBUGF(SNMP_MIB_DEBUG,("expand failed, tree ends here\n"));
return NULL;
}
}
}
/* done, found nothing */
LWIP_DEBUGF(SNMP_MIB_DEBUG,("expand failed node==%p\n",(void*)node));
return NULL;
}
/*
Take the node from the front of the source, and move it to
the front of the dest.
It is an error to call this with the source list empty.
*/
void move_node(struct node** dest, struct node** source)
{
struct node* source_head = pop_node(source);
push_node(dest, source_head);
}
void brubeck_slab_init(struct brubeck_slab *slab)
{
push_node(slab);
pthread_mutex_init(&slab->lock, NULL);
}
