static void findJsTags (void) { g_assert (symbols == NULL); g_assert (tags == NULL); JSNode * global = js_node_new_from_file (getInputFileName()); JSContext *my_cx; GList *calls = NULL; my_cx = js_context_new_from_node (global, &calls); findTags (my_cx); /*Members*/ get_member_list (my_cx); g_list_foreach (tags, (GFunc)makeTagEntry, NULL); findGlobal (my_cx); g_list_free (symbols); symbols = NULL; g_list_free (tags); tags = NULL; }
static void findGlobal (JSContext *my_cx) { static int depth = 0; GList *i; g_assert (my_cx != NULL); g_assert (depth <= 1); for (i = my_cx->local_var; i; i = g_list_next (i)) { const char *name = ((Var*)i->data)->name; gint line = ((Var*)i->data)->line; g_assert (name != NULL); if (g_strstr_len (name, -1, PROTOTYPE) != NULL) continue; tagEntryInfo *tag = (tagEntryInfo*)malloc (sizeof (tagEntryInfo)); initTagEntry (tag, name); get_file_pos (line, &tag->filePosition, File.fp); tag->lineNumber = line; tag->isFileScope = 1; tag->kindName = "variable"; tag->kind = 'v'; Type *t = js_context_get_node_type (my_cx, ((Var*)i->data)->node); if (t) { tag->extensionFields.typeRef [0] = "variable"; tag->extensionFields.typeRef [1] = t->name; g_free (t); } if (my_cx->ret_type) tag->extensionFields.returnType = my_cx->ret_type->data; if (g_list_find_custom (symbols, name, (GCompareFunc)g_strcmp0) == NULL) makeTagEntry (tag); } if (depth == 0) { depth++; for (i = my_cx->childs; i; i = g_list_next (i)) { findGlobal (i->data); } depth--; } }
void CReadCpp::getrelation() { string content = readallfile(CppName); int classstart = -1; int pos = findclasses(0,content); while(pos!=string::npos) { if(classposition != -1 &&classstart == -1) classstart = classposition; pos = findclasses(pos,content); } if(classstart!=string::npos) { getheadfile(classstart,content); } globalStr = findGlobal(content); }
PceObject pceObjectFromName(PceName name) { return findGlobal(name); }
void wrenInitializeCore(WrenVM* vm) { // Define the root Object class. This has to be done a little specially // because it has no superclass and an unusual metaclass (Class). vm->objectClass = defineSingleClass(vm, "Object"); NATIVE(vm->objectClass, "== ", object_eqeq); NATIVE(vm->objectClass, "!= ", object_bangeq); NATIVE(vm->objectClass, "new", object_new); NATIVE(vm->objectClass, "toString", object_toString); NATIVE(vm->objectClass, "type", object_type); NATIVE(vm->objectClass, " instantiate", object_instantiate); // Now we can define Class, which is a subclass of Object, but Object's // metaclass. vm->classClass = defineSingleClass(vm, "Class"); // Now that Object and Class are defined, we can wire them up to each other. wrenBindSuperclass(vm, vm->classClass, vm->objectClass); vm->objectClass->metaclass = vm->classClass; vm->classClass->metaclass = vm->classClass; // Define the methods specific to Class after wiring up its superclass to // prevent the inherited ones from overwriting them. NATIVE(vm->classClass, " instantiate", class_instantiate); NATIVE(vm->classClass, "name", class_name); // The core class diagram ends up looking like this, where single lines point // to a class's superclass, and double lines point to its metaclass: // // __________ /====\ // / \ // \\ // v \ v \\ // .---------. .--------------. // // | Object |==>| Class |==/ // '---------' '--------------' // ^ ^ // | | // .---------. .--------------. \ // | Base |==>| Base.type | | // '---------' '--------------' | // ^ ^ | Hypothetical example classes // | | | // .---------. .--------------. | // | Derived |==>| Derived.type | | // '---------' '--------------' / // The rest of the classes can not be defined normally. vm->boolClass = defineClass(vm, "Bool"); NATIVE(vm->boolClass, "toString", bool_toString); NATIVE(vm->boolClass, "!", bool_not); // TODO: Make fibers inherit Sequence and be iterable. vm->fiberClass = defineClass(vm, "Fiber"); NATIVE(vm->fiberClass->metaclass, " instantiate", fiber_instantiate); NATIVE(vm->fiberClass->metaclass, "new ", fiber_new); NATIVE(vm->fiberClass->metaclass, "yield", fiber_yield); NATIVE(vm->fiberClass->metaclass, "yield ", fiber_yield1); NATIVE(vm->fiberClass, "call", fiber_call); NATIVE(vm->fiberClass, "call ", fiber_call1); NATIVE(vm->fiberClass, "isDone", fiber_isDone); NATIVE(vm->fiberClass, "run", fiber_run); NATIVE(vm->fiberClass, "run ", fiber_run1); vm->fnClass = defineClass(vm, "Fn"); NATIVE(vm->fnClass->metaclass, " instantiate", fn_instantiate); NATIVE(vm->fnClass->metaclass, "new ", fn_new); NATIVE(vm->fnClass, "call", fn_call0); NATIVE(vm->fnClass, "call ", fn_call1); NATIVE(vm->fnClass, "call ", fn_call2); NATIVE(vm->fnClass, "call ", fn_call3); NATIVE(vm->fnClass, "call ", fn_call4); NATIVE(vm->fnClass, "call ", fn_call5); NATIVE(vm->fnClass, "call ", fn_call6); NATIVE(vm->fnClass, "call ", fn_call7); NATIVE(vm->fnClass, "call ", fn_call8); NATIVE(vm->fnClass, "call ", fn_call9); NATIVE(vm->fnClass, "call ", fn_call10); NATIVE(vm->fnClass, "call ", fn_call11); NATIVE(vm->fnClass, "call ", fn_call12); NATIVE(vm->fnClass, "call ", fn_call13); NATIVE(vm->fnClass, "call ", fn_call14); NATIVE(vm->fnClass, "call ", fn_call15); NATIVE(vm->fnClass, "call ", fn_call16); NATIVE(vm->fnClass, "toString", fn_toString); vm->nullClass = defineClass(vm, "Null"); NATIVE(vm->nullClass, "toString", null_toString); vm->numClass = defineClass(vm, "Num"); NATIVE(vm->numClass, "abs", num_abs); NATIVE(vm->numClass, "ceil", num_ceil); NATIVE(vm->numClass, "cos", num_cos); NATIVE(vm->numClass, "floor", num_floor); NATIVE(vm->numClass, "isNan", num_isNan); NATIVE(vm->numClass, "sin", num_sin); NATIVE(vm->numClass, "sqrt", num_sqrt); NATIVE(vm->numClass, "toString", num_toString) NATIVE(vm->numClass, "-", num_negate); NATIVE(vm->numClass, "- ", num_minus); NATIVE(vm->numClass, "+ ", num_plus); NATIVE(vm->numClass, "* ", num_multiply); NATIVE(vm->numClass, "/ ", num_divide); NATIVE(vm->numClass, "% ", num_mod); NATIVE(vm->numClass, "< ", num_lt); NATIVE(vm->numClass, "> ", num_gt); NATIVE(vm->numClass, "<= ", num_lte); NATIVE(vm->numClass, ">= ", num_gte); NATIVE(vm->numClass, "~", num_bitwiseNot); NATIVE(vm->numClass, "& ", num_bitwiseAnd); NATIVE(vm->numClass, "| ", num_bitwiseOr); NATIVE(vm->numClass, ".. ", num_dotDot); NATIVE(vm->numClass, "... ", num_dotDotDot); vm->stringClass = defineClass(vm, "String"); NATIVE(vm->stringClass, "contains ", string_contains); NATIVE(vm->stringClass, "count", string_count); NATIVE(vm->stringClass, "toString", string_toString) NATIVE(vm->stringClass, "+ ", string_plus); NATIVE(vm->stringClass, "== ", string_eqeq); NATIVE(vm->stringClass, "!= ", string_bangeq); NATIVE(vm->stringClass, "[ ]", string_subscript); wrenInterpret(vm, "Wren core library", libSource); vm->listClass = AS_CLASS(findGlobal(vm, "List")); NATIVE(vm->listClass->metaclass, " instantiate", list_instantiate); NATIVE(vm->listClass, "add ", list_add); NATIVE(vm->listClass, "clear", list_clear); NATIVE(vm->listClass, "count", list_count); NATIVE(vm->listClass, "insert ", list_insert); NATIVE(vm->listClass, "iterate ", list_iterate); NATIVE(vm->listClass, "iteratorValue ", list_iteratorValue); NATIVE(vm->listClass, "removeAt ", list_removeAt); NATIVE(vm->listClass, "[ ]", list_subscript); NATIVE(vm->listClass, "[ ]=", list_subscriptSetter); vm->rangeClass = AS_CLASS(findGlobal(vm, "Range")); NATIVE(vm->rangeClass, "from", range_from); NATIVE(vm->rangeClass, "to", range_to); NATIVE(vm->rangeClass, "min", range_min); NATIVE(vm->rangeClass, "max", range_max); NATIVE(vm->rangeClass, "isInclusive", range_isInclusive); NATIVE(vm->rangeClass, "iterate ", range_iterate); NATIVE(vm->rangeClass, "iteratorValue ", range_iteratorValue); NATIVE(vm->rangeClass, "toString", range_toString); // These are defined just so that 0 and -0 are equal, which is specified by // IEEE 754 even though they have different bit representations. NATIVE(vm->numClass, "== ", num_eqeq); NATIVE(vm->numClass, "!= ", num_bangeq); }