JsonOutput::ObjectRef JsonOutput::convert(DemangledType const & sym) const { // This is not yet finished auto node = builder.object(); auto & obj = *node; handle_symbol_type(obj, sym); handle_scope(obj, sym); if (sym.symbol_type == SymbolType::GlobalFunction || sym.symbol_type == SymbolType::ClassMethod) { handle_distance(obj, sym); if (sym.retval) { obj.add("return_type", convert(*sym.retval)); } obj.add("calling_convention", sym.calling_convention); } handle_namespace(obj, sym); return std::move(node); }
int jdip::context_parser::handle_scope(definition_scope *scope, token_t& token, unsigned inherited_flags) { definition* decl; token = read_next_token(scope); for (;;) { switch (token.type) { case TT_TYPENAME: case TT_DECFLAG: case TT_DECLTYPE: case TT_DECLARATOR: case_TT_DECLARATOR: case TT_CLASS: case TT_STRUCT: case TT_ENUM: case TT_UNION: case TT_TILDE: decl = NULL; handle_declarator_block: if (handle_declarators(scope, token, inherited_flags, decl)) { FATAL_RETURN(1); while (token.type != TT_ENDOFCODE and token.type != TT_SEMICOLON and token.type != TT_LEFTBRACE and token.type != TT_RIGHTBRACE) token = read_next_token(scope); } handled_declarator_block: if (token.type != TT_SEMICOLON) { if (token.type == TT_LEFTBRACE || token.type == TT_ASM) { if (!(decl and decl->flags & DEF_FUNCTION)) { token.report_error(herr, "Unexpected opening brace here; declaration is not a function"); FATAL_RETURN(1); handle_function_implementation(lex,token,scope,herr); } else ((definition_function*)decl)->implementation = handle_function_implementation(lex,token,scope,herr); if (token.type != TT_RIGHTBRACE && token.type != TT_SEMICOLON) { token.report_error(herr, "Expected closing symbol to function"); continue; } } else { token.report_errorf(herr, "Expected semicolon before %s following declaration"); #if FATAL_ERRORS return 1; #else semicolon_bail: while (token.type != TT_SEMICOLON && token.type != TT_LEFTBRACE && token.type != TT_RIGHTBRACE && token.type != TT_ENDOFCODE) token = read_next_token(scope); if (token.type == TT_LEFTBRACE) { size_t depth = 1; while (token.type != TT_ENDOFCODE) { token = read_next_token(scope); if (token.type == TT_LEFTBRACE) ++depth; else if (token.type == TT_RIGHTBRACE) if (!--depth) break; } } #endif } } break; case TT_EXTERN: token = read_next_token(scope); if (token.type == TT_STRINGLITERAL) { token = read_next_token(scope); if (token.type == TT_LEFTBRACE) { FATAL_RETURN_IF(handle_scope(scope, token, inherited_flags), 1); if (token.type != TT_RIGHTBRACE) { token.report_error(herr, "Expected closing brace to extern block"); FATAL_RETURN(1); } break; } } else if (token.type == TT_TEMPLATE) { token = read_next_token(scope); if (token.type != TT_CLASS and token.type != TT_STRUCT and token.type != TT_DECLARATOR and token.type != TT_DEFINITION) { token.report_errorf(herr, "Expected template specialization following `extern template' directive; %s unhandled"); FATAL_RETURN(1); } } goto handle_declarator_block; case TT_COMMA: token.report_error(herr, "Unexpected comma at this point."); return 1; case TT_SEMICOLON: /* Printing a warning here is advisable but unnecessary. */ break; case TT_NAMESPACE: if (handle_namespace(scope,token)) return 1; break; case TT_LEFTPARENTH: { token.report_error(herr, "Stray opening parenthesis."); #if FATAL_ERRORS return 1; #else int bc = 1; while (bc) { token = read_next_token(scope); bc += token.type == TT_LEFTPARENTH; bc -= token.type == TT_RIGHTPARENTH; } #endif } break; case TT_RIGHTPARENTH: token.report_error(herr, "Stray closing parenthesis."); return 1; case TT_LEFTBRACKET: token.report_error(herr, "Stray opening bracket."); return 1; case TT_RIGHTBRACKET: token.report_error(herr, "Stray closing bracket."); return 1; case TT_RIGHTBRACE: return 0; case TT_LEFTBRACE: { token.report_error(herr, "Expected scope declaration before opening brace."); #if FATAL_ERRORS return 1; #else int bc = 1; while (bc) { token = read_next_token(scope); if (token.type == TT_ENDOFCODE) { token.report_error(herr, "Expected closing brace before end of code."); return 1; } bc += token.type == TT_LEFTBRACE; bc -= token.type == TT_RIGHTBRACE; } #endif } break; case TT_TYPEDEF: token = read_next_token(scope); if (handle_declarators(scope,token,inherited_flags | DEF_TYPENAME)) FATAL_RETURN(1); break; case TT_PUBLIC: if (scope->flags & DEF_CLASS) { inherited_flags &= ~(DEF_PRIVATE | DEF_PROTECTED); } else token.report_error(herr, "Unexpected `public' token outside class scope."); if ((token = read_next_token(scope)).type != TT_COLON) token.report_error(herr, "Colon expected following `public' token"); break; case TT_PRIVATE: if (scope->flags & DEF_CLASS) { inherited_flags &= ~(DEF_PRIVATE | DEF_PROTECTED); inherited_flags |= DEF_PRIVATE; } else token.report_error(herr, "Unexpected `private' token outside class scope."); if ((token = read_next_token(scope)).type != TT_COLON) token.report_error(herr, "Colon expected following `private' token"); break; case TT_PROTECTED: if (scope->flags & DEF_CLASS) { inherited_flags &= ~(DEF_PRIVATE | DEF_PROTECTED); inherited_flags |= DEF_PROTECTED; } else token.report_error(herr, "Unexpected `protected' token outside class scope."); if ((token = read_next_token(scope)).type != TT_COLON) token.report_error(herr, "Colon expected following `protected' token"); break; case TT_USING: token = read_next_token(scope); if (token.type == TT_NAMESPACE) { token = lex->get_token(herr); if (token.type == TT_IDENTIFIER) { definition* d = scope->look_up(token.content.toString()); if (!d) { token.report_errorf(herr, "Expected id to use before %s"); FATAL_RETURN(1); } else { if (d->flags & DEF_NAMESPACE) scope->use_namespace((definition_scope*)d); else token.report_error(herr, "Expected namespace name following `namespace' token"); } token = read_next_token(scope); } else token.report_error(herr, "Expected namespace name following `namespace' token"); } else { definition *usedef = read_qualified_definition(lex, scope, token, this, herr); if (usedef) scope->use_general(usedef->name, usedef); else { token.report_errorf(herr, "Using directive does not specify an object"); FATAL_RETURN(1); } if (token.type != TT_SEMICOLON) { token.report_errorf(herr, "Expected semicolon before %s to terminate using directive"); FATAL_RETURN(1); } } break; case TT_SCOPE: token = read_next_token(global); continue; case TT_DEFINITION: { if (token.def->flags & DEF_NAMESPACE) { definition_scope* dscope = (definition_scope*)token.def; token = read_next_token(scope); if (token.type == TT_SCOPE) { token = read_next_token(dscope); continue; } token.report_errorf(herr, "Expected `::' here to access namespace members"); FATAL_RETURN(1); break; } if (token.def->flags & DEF_TEMPLATE) goto case_TT_DECLARATOR; } case TT_IDENTIFIER: { string tname(token.content.toString()); if (tname == scope->name and (scope->flags & DEF_CLASS)) { token = read_next_token(scope); if (token.type != TT_LEFTPARENTH) { token.report_errorf(herr, "Expected constructor parmeters before %s"); break; } full_type ft; ft.def = scope; token = read_next_token(scope); read_function_params(ft.refs, lex, token, scope, this, herr); if (handle_declarators(scope,token,ft,inherited_flags | DEF_TYPENAME,decl)) FATAL_RETURN(1); goto handled_declarator_block; } token.report_error(herr, "Unexpected identifier in this scope; `" + tname + "' does not name a type"); } break; case TT_TEMPLATE: if (handle_template(scope, token, inherited_flags)) { FATAL_RETURN(1); goto semicolon_bail; } break; case TT_OPERATORKW: token = read_next_token(scope); if (token.type != TT_DECLARATOR and token.type != TT_DECFLAG and token.type != TT_DECLTYPE) { token.report_errorf(herr, "Expected cast type to overload before %s"); FATAL_RETURN(1); } else { lex_buffer lb(lex); while (token.type != TT_LEFTPARENTH and token.type != TT_LEFTBRACE and token.type != TT_SEMICOLON and token.type != TT_ENDOFCODE) lb.push(token), token = read_next_token(scope); if (token.type != TT_LEFTPARENTH) { token.report_error(herr, "Expected function parmeters before %s"); FATAL_RETURN(1); break; } token.type = TT_ENDOFCODE; lb.push(token); token.type = TT_LEFTPARENTH; lb.reset(); token_t kick = lb.get_token(herr); full_type ft = read_fulltype(&lb, kick, scope, this, herr); string opname; { ref_stack my_func_refs; read_referencers_post(my_func_refs, lex, token, scope, this, herr); if (my_func_refs.empty() or my_func_refs.top().type != ref_stack::RT_FUNCTION) { token.report_error(herr, "Expected function parameters for operator overload"); return 1; } opname = "operator " + ft.toString(); ft.refs.append_c(my_func_refs); } definition_function *const df = new definition_function(opname, scope, ft.def, ft.refs, ft.flags, inherited_flags); decl = df; decpair ins = scope->declare(decl->name, decl); if (!ins.inserted) { arg_key k(df->referencers); decl = ((definition_function*)ins.def)->overload(k, df, herr); } goto handled_declarator_block; } break; case TT_ASM: case TT_SIZEOF: case TT_ISEMPTY: case TT_OPERATOR: case TT_ELLIPSIS: case TT_LESSTHAN: case TT_GREATERTHAN: case TT_COLON: case TT_DECLITERAL: case TT_HEXLITERAL: case TT_OCTLITERAL: case TT_STRINGLITERAL: case TT_CHARLITERAL: case TT_NEW: case TT_DELETE: case TTM_CONCAT: case TTM_TOSTRING: case TT_INVALID: #include <User/token_cases.h> default: token.report_errorf(herr, "Unexpected %s in this scope"); break; case TT_ENDOFCODE: return 0; } token = read_next_token(scope); } }
int jdip::context_parser::handle_scope(definition_scope *scope, token_t& token, unsigned inherited_flags) { definition* decl; token = read_next_token(scope); for (;;) { switch (token.type) { case TT_TYPENAME: case TT_DECFLAG: case TT_DECLTYPE: case TT_DECLARATOR: case_TT_DECLARATOR: case TT_CLASS: case TT_STRUCT: case TT_ENUM: case TT_UNION: case TT_TILDE: decl = NULL; handle_declarator_block: if (handle_declarators(scope, token, inherited_flags, decl)) { FATAL_RETURN(1); while (token.type != TT_ENDOFCODE and token.type != TT_SEMICOLON and token.type != TT_LEFTBRACE and token.type != TT_RIGHTBRACE) token = read_next_token(scope); } handled_declarator_block: if (token.type != TT_SEMICOLON) { if (token.type == TT_LEFTBRACE || token.type == TT_ASM) { if (!(decl and decl->flags & DEF_OVERLOAD)) { token.report_error(herr, "Unexpected opening brace here; declaration is not a function"); FATAL_RETURN(1); handle_function_implementation(lex,token,scope,herr); } else { definition_overload *ovr = ((definition_overload*)decl); if (ovr->implementation != NULL) { token.report_error(herr, "Multiple implementations of function" FATAL_TERNARY("", "; old implementation discarded")); delete_function_implementation(ovr->implementation); } ovr->implementation = handle_function_implementation(lex,token,scope,herr); } if (token.type != TT_RIGHTBRACE && token.type != TT_SEMICOLON) { token.report_error(herr, "Expected closing symbol to function"); continue; } } else { token.report_errorf(herr, "Expected semicolon before %s following declaration"); #if FATAL_ERRORS return 1; #else semicolon_bail: while (token.type != TT_SEMICOLON && token.type != TT_LEFTBRACE && token.type != TT_RIGHTBRACE && token.type != TT_ENDOFCODE) token = read_next_token(scope); if (token.type == TT_LEFTBRACE) { size_t depth = 1; while (token.type != TT_ENDOFCODE) { token = read_next_token(scope); if (token.type == TT_LEFTBRACE) ++depth; else if (token.type == TT_RIGHTBRACE) if (!--depth) break; } } #endif } } break; case TT_EXTERN: token = read_next_token(scope); if (token.type == TT_STRINGLITERAL) { token = read_next_token(scope); if (token.type == TT_LEFTBRACE) { FATAL_RETURN_IF(handle_scope(scope, token, inherited_flags), 1); if (token.type != TT_RIGHTBRACE) { token.report_error(herr, "Expected closing brace to extern block"); FATAL_RETURN(1); } break; } } else if (token.type == TT_TEMPLATE) { token = read_next_token(scope); if (token.type != TT_CLASS and token.type != TT_STRUCT and token.type != TT_DECLARATOR and token.type != TT_DECFLAG and token.type != TT_DEFINITION) { token.report_errorf(herr, "Expected template specialization following `extern template' directive; %s unhandled"); FATAL_RETURN(1); } if (handle_template_extern(scope, token, inherited_flags)) FATAL_RETURN(1); break; } goto handle_declarator_block; case TT_COMMA: token.report_error(herr, "Unexpected comma at this point."); return 1; case TT_SEMICOLON: /* Printing a warning here is advisable but unnecessary. */ break; case TT_NAMESPACE: if (handle_namespace(scope,token)) return 1; break; case TT_LEFTPARENTH: { token.report_error(herr, "Stray opening parenthesis."); #if FATAL_ERRORS return 1; #else int bc = 1; while (bc) { token = read_next_token(scope); bc += token.type == TT_LEFTPARENTH; bc -= token.type == TT_RIGHTPARENTH; } #endif } break; case TT_RIGHTPARENTH: token.report_error(herr, "Stray closing parenthesis."); return 1; case TT_LEFTBRACKET: token.report_error(herr, "Stray opening bracket."); return 1; case TT_RIGHTBRACKET: token.report_error(herr, "Stray closing bracket."); return 1; case TT_RIGHTBRACE: return 0; case TT_LEFTBRACE: { token.report_error(herr, "Expected scope declaration before opening brace."); #if FATAL_ERRORS return 1; #else int bc = 1; while (bc) { token = read_next_token(scope); if (token.type == TT_ENDOFCODE) { token.report_error(herr, "Expected closing brace before end of code."); return 1; } bc += token.type == TT_LEFTBRACE; bc -= token.type == TT_RIGHTBRACE; } #endif } break; case TT_TYPEDEF: token = read_next_token(scope); if (handle_declarators(scope,token,inherited_flags | DEF_TYPENAME)) FATAL_RETURN(1); break; case TT_PUBLIC: if (scope->flags & DEF_CLASS) { inherited_flags &= ~(DEF_PRIVATE | DEF_PROTECTED); } else token.report_error(herr, "Unexpected `public' token outside class scope."); if ((token = read_next_token(scope)).type != TT_COLON) token.report_error(herr, "Colon expected following `public' token"); break; case TT_PRIVATE: if (scope->flags & DEF_CLASS) { inherited_flags &= ~(DEF_PRIVATE | DEF_PROTECTED); inherited_flags |= DEF_PRIVATE; } else token.report_error(herr, "Unexpected `private' token outside class scope."); if ((token = read_next_token(scope)).type != TT_COLON) token.report_error(herr, "Colon expected following `private' token"); break; case TT_PROTECTED: if (scope->flags & DEF_CLASS) { inherited_flags &= ~(DEF_PRIVATE | DEF_PROTECTED); inherited_flags |= DEF_PROTECTED; } else token.report_error(herr, "Unexpected `protected' token outside class scope."); if ((token = read_next_token(scope)).type != TT_COLON) token.report_error(herr, "Colon expected following `protected' token"); break; case TT_FRIEND: if (!(scope->flags & DEF_CLASS)) { token.report_error(herr, "`friend' statement may only appear in a class or structure"); FATAL_RETURN(1); while ((token = read_next_token(scope)).type != TT_SEMICOLON && token.type != TT_RIGHTBRACE && token.type != TT_ENDOFCODE); } else { if (handle_friend(scope, token, (definition_class*)scope)) FATAL_RETURN(1); if (token.type == TT_SEMICOLON) token = read_next_token(scope); else { token.report_errorf(herr, "Expected semicolon before %s"); FATAL_RETURN(1); } } continue; case TT_USING: token = read_next_token(scope); if (token.type == TT_NAMESPACE) { token = lex->get_token_in_scope(scope, herr); if (token.type == TT_DEFINITION) { definition *d = read_qualified_definition(token, scope); if (!d) { token.report_errorf(herr, "Expected namespace-name following `namespace' token"); FATAL_RETURN(1); } else { if (d->flags & DEF_NAMESPACE) scope->use_namespace((definition_scope*)d); else token.report_error(herr, "Expected namespace-name following `namespace' token"); } if (token.type == TT_SEMICOLON) token = read_next_token(scope); else { token.report_errorf(herr, "Expected semicolon before %s"); FATAL_RETURN(1); } } else { token.report_errorf(herr, "Expected namespace to use before %s"); FATAL_RETURN(1); } } else { definition *usedef = read_qualified_definition(token, scope); if (usedef) scope->use_general(usedef->name, usedef); else { token.report_errorf(herr, "Using directive does not specify an object"); FATAL_RETURN(1); } if (token.type != TT_SEMICOLON) { token.report_errorf(herr, "Expected semicolon before %s to terminate using directive"); FATAL_RETURN(1); } } continue; case TT_SCOPE: token = read_next_token(ctex->get_global()); continue; case TT_MEMBEROF: token.report_error(herr, "Unexpected (scope::*) reference"); return 1; case TT_STATIC_ASSERT: token.report_error(herr, "Unimplemented: static assert"); break; case TT_AUTO: token.report_error(herr, "Unimplemented: `auto' type inference"); break; case TT_CONSTEXPR: token.report_error(herr, "Unimplemented: const expressions outside enum"); break; case TT_DEFINITION: { if (token.def->flags & DEF_NAMESPACE) { definition_scope* dscope = (definition_scope*)token.def; token = read_next_token(scope); if (token.type == TT_SCOPE) { token = read_next_token(dscope); continue; } token.report_errorf(herr, "Expected `::' here to access namespace members"); FATAL_RETURN(1); break; } if (token.def->flags & DEF_TEMPLATE) goto case_TT_DECLARATOR; } case TT_IDENTIFIER: { string tname(token.content.toString()); if (tname == scope->name and (scope->flags & DEF_CLASS)) { token = read_next_token(scope); if (token.type != TT_LEFTPARENTH) { token.report_errorf(herr, "Expected constructor parmeters before %s"); break; } full_type ft; ft.def = scope; token = read_next_token(scope); read_function_params(ft.refs, token, scope); if (handle_declarators(scope,token,ft,inherited_flags | DEF_TYPENAME,decl)) FATAL_RETURN(1); goto handled_declarator_block; } token.report_error(herr, "Unexpected identifier in this scope (" + scope->name + "); `" + tname + "' does not name a type"); } break; case TT_TEMPLATE: if (handle_template(scope, token, inherited_flags)) { FATAL_RETURN(1); goto semicolon_bail; } break; case TT_OPERATORKW: { full_type ft = read_operatorkw_cast_type(token, scope); if (!ft.def) return 1; if (!(decl = scope->overload_function("(cast)", ft, inherited_flags, token, herr))) return 1; goto handled_declarator_block; } break; case TT_ASM: case TT_SIZEOF: case TT_ISEMPTY: case TT_ALIGNOF: case TT_ALIGNAS: case TT_OPERATOR: case TT_ELLIPSIS: case TT_LESSTHAN: case TT_GREATERTHAN: case TT_COLON: case TT_DECLITERAL: case TT_HEXLITERAL: case TT_OCTLITERAL: case TT_STRINGLITERAL: case TT_CHARLITERAL: case TT_NEW: case TT_DELETE: case TTM_CONCAT: case TTM_TOSTRING: case TT_INVALID: case TT_CONST_CAST: case TT_STATIC_CAST: case TT_DYNAMIC_CAST: case TT_REINTERPRET_CAST: case TT_NOEXCEPT: case TT_TYPEID: #include <User/token_cases.h> default: token.report_errorf(herr, "Unexpected %s in this scope"); break; case TT_ENDOFCODE: return 0; } token = read_next_token(scope); } }
void k8s_dispatcher::dispatch() { for (list::iterator it = m_messages.begin(); it != m_messages.end();) { if(is_ready(*it)) { Json::Value root; Json::Reader reader; if(reader.parse(*it, root, false)) { std::ostringstream os; msg_data data = get_msg_data(root); if(data.is_valid()) { std::ostringstream os; os << '[' << to_reason_desc(data.m_reason) << ','; switch (m_type) { case k8s_component::K8S_NODES: os << "NODE,"; handle_node(root, data); break; case k8s_component::K8S_NAMESPACES: os << "NAMESPACE,"; handle_namespace(root, data); break; case k8s_component::K8S_PODS: os << "POD,"; handle_pod(root, data); break; case k8s_component::K8S_REPLICATIONCONTROLLERS: os << "REPLICATION_CONTROLLER,"; handle_rc(root, data); break; case k8s_component::K8S_SERVICES: os << "SERVICE,"; handle_service(root, data); break; default: { std::ostringstream eos; eos << "Unknown component: " << static_cast<int>(m_type); throw sinsp_exception(os.str()); } } os << data.m_name << ',' << data.m_uid << ',' << data.m_namespace << ']'; g_logger.log(os.str(), sinsp_logger::SEV_INFO); //g_logger.log(root.toStyledString(), sinsp_logger::SEV_DEBUG); { K8S_LOCK_GUARD_MUTEX; m_state.update_cache(m_type); } } } else { // TODO: bad notification - discard or throw? g_logger.log("Bad JSON message received.", sinsp_logger::SEV_ERROR); } it = m_messages.erase(it); } else { ++it; } } }