Lines Matching refs:node
137 #define EVENT_FILTERS(node) (&(((EventFilterPrivate_HandlerNode*)(void*)node)->ef))
138 #define FILTER_COUNT(node) (EVENT_FILTERS(node)->filterCount)
139 #define FILTERS_ARRAY(node) (EVENT_FILTERS(node)->filters)
140 #define FILTER(node,index) ((FILTERS_ARRAY(node))[index])
141 #define NODE_EI(node) (node->ei)
156 HandlerNode *node = jvmtiAllocate((jint)size);
158 if (node != NULL) {
162 (void)memset(node, 0, size);
164 FILTER_COUNT(node) = filterCount;
168 for (i = 0, filter = FILTERS_ARRAY(node);
175 return node;
183 clearFilters(HandlerNode *node)
188 Filter *filter = FILTERS_ARRAY(node);
190 for (i = 0; i < FILTER_COUNT(node); ++i, ++filter) {
233 FILTER_COUNT(node) = 0; /* blast so we don't clear again */
371 * and the corresponding node should be deleted.
377 HandlerNode *node,
383 Filter *filter = FILTERS_ARRAY(node);
401 for (i = 0; i < FILTER_COUNT(node); ++i, ++filter) {
559 * and the corresponding node should be deleted.
564 HandlerNode *node,
567 Filter *filter = FILTERS_ARRAY(node);
571 for (i = 0; i < FILTER_COUNT(node); ++i, ++filter) {
609 * all events for the given node in the given stack frame will
617 eventFilter_predictFiltering(HandlerNode *node, jclass clazz, char *classname)
628 filter = FILTERS_ARRAY(node);
629 count = FILTER_COUNT(node);
681 * Determine if the given breakpoint node is in the specified class.
685 HandlerNode *node)
687 Filter *filter = FILTERS_ARRAY(node);
690 for (i = 0; i < FILTER_COUNT(node); ++i, ++filter) {
702 eventFilter_setConditionalFilter(HandlerNode *node, jint index,
705 ConditionalFilter *filter = &FILTER(node, index).u.Conditional;
706 if (index >= FILTER_COUNT(node)) {
709 FILTER(node, index).modifier = JDWP_REQUEST_MODIFIER(Conditional);
715 eventFilter_setCountFilter(HandlerNode *node, jint index,
718 CountFilter *filter = &FILTER(node, index).u.Count;
719 if (index >= FILTER_COUNT(node)) {
725 FILTER(node, index).modifier = JDWP_REQUEST_MODIFIER(Count);
732 eventFilter_setThreadOnlyFilter(HandlerNode *node, jint index,
736 ThreadFilter *filter = &FILTER(node, index).u.ThreadOnly;
737 if (index >= FILTER_COUNT(node)) {
740 if (NODE_EI(node) == EI_GC_FINISH) {
747 FILTER(node, index).modifier = JDWP_REQUEST_MODIFIER(ThreadOnly);
752 eventFilter_setLocationOnlyFilter(HandlerNode *node, jint index,
757 LocationFilter *filter = &FILTER(node, index).u.LocationOnly;
758 if (index >= FILTER_COUNT(node)) {
761 if ((NODE_EI(node) != EI_BREAKPOINT) &&
762 (NODE_EI(node) != EI_FIELD_ACCESS) &&
763 (NODE_EI(node) != EI_FIELD_MODIFICATION) &&
764 (NODE_EI(node) != EI_SINGLE_STEP) &&
765 (NODE_EI(node) != EI_EXCEPTION)) {
773 FILTER(node, index).modifier = JDWP_REQUEST_MODIFIER(LocationOnly);
780 eventFilter_setFieldOnlyFilter(HandlerNode *node, jint index,
784 FieldFilter *filter = &FILTER(node, index).u.FieldOnly;
785 if (index >= FILTER_COUNT(node)) {
788 if ((NODE_EI(node) != EI_FIELD_ACCESS) &&
789 (NODE_EI(node) != EI_FIELD_MODIFICATION)) {
797 FILTER(node, index).modifier = JDWP_REQUEST_MODIFIER(FieldOnly);
803 eventFilter_setClassOnlyFilter(HandlerNode *node, jint index,
807 ClassFilter *filter = &FILTER(node, index).u.ClassOnly;
808 if (index >= FILTER_COUNT(node)) {
812 (NODE_EI(node) == EI_GC_FINISH) ||
813 (NODE_EI(node) == EI_THREAD_START) ||
814 (NODE_EI(node) == EI_THREAD_END)) {
822 FILTER(node, index).modifier = JDWP_REQUEST_MODIFIER(ClassOnly);
827 eventFilter_setExceptionOnlyFilter(HandlerNode *node, jint index,
833 ExceptionFilter *filter = &FILTER(node, index).u.ExceptionOnly;
834 if (index >= FILTER_COUNT(node)) {
837 if (NODE_EI(node) != EI_EXCEPTION) {
847 FILTER(node, index).modifier =
855 eventFilter_setInstanceOnlyFilter(HandlerNode *node, jint index,
859 InstanceFilter *filter = &FILTER(node, index).u.InstanceOnly;
860 if (index >= FILTER_COUNT(node)) {
871 FILTER(node, index).modifier =
877 eventFilter_setClassMatchFilter(HandlerNode *node, jint index,
880 MatchFilter *filter = &FILTER(node, index).u.ClassMatch;
881 if (index >= FILTER_COUNT(node)) {
885 (NODE_EI(node) == EI_THREAD_START) ||
886 (NODE_EI(node) == EI_THREAD_END)) {
891 FILTER(node, index).modifier =
898 eventFilter_setClassExcludeFilter(HandlerNode *node, jint index,
901 MatchFilter *filter = &FILTER(node, index).u.ClassExclude;
902 if (index >= FILTER_COUNT(node)) {
906 (NODE_EI(node) == EI_THREAD_START) ||
907 (NODE_EI(node) == EI_THREAD_END)) {
912 FILTER(node, index).modifier =
919 eventFilter_setStepFilter(HandlerNode *node, jint index,
924 StepFilter *filter = &FILTER(node, index).u.Step;
925 if (index >= FILTER_COUNT(node)) {
928 if (NODE_EI(node) != EI_SINGLE_STEP) {
935 error = stepControl_beginStep(env, filter->thread, size, depth, node);
940 FILTER(node, index).modifier = JDWP_REQUEST_MODIFIER(Step);
948 eventFilter_setSourceNameMatchFilter(HandlerNode *node,
951 SourceNameFilter *filter = &FILTER(node, index).u.SourceNameOnly;
952 if (index >= FILTER_COUNT(node)) {
955 if (NODE_EI(node) != EI_CLASS_PREPARE) {
959 FILTER(node, index).modifier =
973 findFilter(HandlerNode *node, jint modifier)
977 for (i = 0, filter = FILTERS_ARRAY(node);
978 i <FILTER_COUNT(node);
988 * Determine if the specified breakpoint node is in the
995 matchBreakpoint(JNIEnv *env, HandlerNode *node, void *arg)
998 Filter *filter = FILTERS_ARRAY(node);
1001 for (i = 0; i < FILTER_COUNT(node); ++i, ++filter) {
1020 setBreakpoint(HandlerNode *node)
1025 filter = findFilter(node, JDWP_REQUEST_MODIFIER(LocationOnly));
1050 clearBreakpoint(HandlerNode *node)
1055 filter = findFilter(node, JDWP_REQUEST_MODIFIER(LocationOnly));
1093 * Determine if the specified watchpoint node has the
1100 matchWatchpoint(JNIEnv *env, HandlerNode *node, void *arg)
1103 Filter *filter = FILTERS_ARRAY(node);
1106 for (i = 0; i < FILTER_COUNT(node); ++i, ++filter) {
1124 setWatchpoint(HandlerNode *node)
1129 filter = findFilter(node, JDWP_REQUEST_MODIFIER(FieldOnly));
1140 NODE_EI(node), matchWatchpoint, ff)) {
1141 error = (NODE_EI(node) == EI_FIELD_ACCESS) ?
1155 clearWatchpoint(HandlerNode *node)
1160 filter = findFilter(node, JDWP_REQUEST_MODIFIER(FieldOnly));
1171 NODE_EI(node), matchWatchpoint, ff)) {
1172 error = (NODE_EI(node) == EI_FIELD_ACCESS) ?
1183 * Determine the thread this node is filtered on.
1187 requestThread(HandlerNode *node)
1190 Filter *filter = FILTERS_ARRAY(node);
1192 for (i = 0; i < FILTER_COUNT(node); ++i, ++filter) {
1203 * Determine if the specified node has a
1210 matchThread(JNIEnv *env, HandlerNode *node, void *arg)
1213 jthread reqThread = requestThread(node);
1223 * needed to get the events requested by this handler node.
1226 enableEvents(HandlerNode *node)
1230 switch (NODE_EI(node)) {
1249 error = setWatchpoint(node);
1253 error = setBreakpoint(node);
1262 jthread thread = requestThread(node);
1269 NODE_EI(node), matchThread, thread)) {
1271 NODE_EI(node), thread);
1279 * needed to no longer get the events requested by this handler node.
1282 disableEvents(HandlerNode *node)
1289 switch (NODE_EI(node)) {
1308 error = clearWatchpoint(node);
1312 error = clearBreakpoint(node);
1319 thread = requestThread(node);
1327 if (!eventHandlerRestricted_iterator(NODE_EI(node), matchThread, thread)) {
1329 NODE_EI(node), thread);
1339 * node active (including enabling the corresponding events).
1342 eventFilterRestricted_install(HandlerNode *node)
1344 return enableEvents(node);
1349 * node inactive (including disabling the corresponding events
1353 eventFilterRestricted_deinstall(HandlerNode *node)
1357 error1 = disableEvents(node);
1358 error2 = clearFilters(node);