Diff
Not logged in
Home Timeline Branches Tags Tickets Wiki Login
Annotate Patch Side-by-side Diff

Differences From Artifact [4b3c37fbfb]:

To Artifact [047a5a7fb3]:

︙
618
619
620
621
622
623
624














































































































625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657

658
659
660
661
662
663
664
665
666
667
668
669
670
671
672

673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699



700
701

702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725


726
727
728
729
730
731
732

733

734
735









736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755


756
757
758
759
760
761
762

618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751














752

753



754
755
756
757
758
759
760
761
762



763



























764
765
766


767





















768


769
770
771
772




773
774

775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804


805
806
807
808
809
810
811
812
813








+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

















-
-
-
-
-
-
-
-
-
-
-
-
-
-

-
+
-
-
-









-
-
-
+
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
-
-
+
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-

-
-
+
+


-
-
-
-

+
-
+


+
+
+
+
+
+
+
+
+


















-
-
+
+









  failPrecondition:
    Tcl_ResetResult(interp);
    Tcl_SetObjResult(interp, Tcl_NewBooleanObj(0));
    return TCL_OK;
}

/*
 * Scopes as passed via the -scope option to [info class methods] and [info
 * object methods].
 */
enum Scopes {
    SCOPE_PRIVATE,		/* User said -scope private */
    SCOPE_PUBLIC,		/* User said -scope public */
    SCOPE_UNEXPORTED,		/* User said -scope unexported */
#ifdef TCLOO_SUPPORT_LOCALPRIVATE_SCOPE_IN_INFO_METHODS
    SCOPE_LOCALPRIVATE,		/* User said -scope localprivate (not enabled) */
#endif
    SCOPE_NONE = -1		/* No scope set. Use old semantics. */
};

static inline int
ParseMethodsArgs(
    Tcl_Interp *interp,
    int objc,
    Tcl_Obj *const objv[],
    int *recursePtr,
    int *flagPtr,
    int *scopePtr)
{
    static const char *const scopes[] = {
	"private", "public", "unexported"
#ifdef TCLOO_SUPPORT_LOCALPRIVATE_SCOPE_IN_INFO_METHODS
	, "localprivate"
#endif
    };
    static const char *const options[] = {
	"-all", "-localprivate", "-private", "-scope", NULL
    };
    enum Options {
	OPT_ALL, OPT_LOCALPRIVATE, OPT_PRIVATE, OPT_SCOPE
    } idx;
    int i;

    /*
     * Set the defaults.
     */
    *flagPtr = PUBLIC_METHOD, *recursePtr = 0, *scopePtr = SCOPE_NONE;
    if (objc == 2) {
	return TCL_OK;
    }

    /*
     * Parse the options.
     */
    for (i=2 ; i<objc ; i++) {
	if (Tcl_GetIndexFromObj(interp, objv[i], options, "option", 0,
		&idx) != TCL_OK) {
	    return TCL_ERROR;
	}
	switch (idx) {
	case OPT_ALL:
	    *recursePtr = 1;
	    break;
	case OPT_LOCALPRIVATE:
	    *flagPtr = PRIVATE_METHOD;
	    break;
	case OPT_PRIVATE:
	    *flagPtr = 0;
	    break;
	case OPT_SCOPE:
	    if (++i >= objc) {
		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
			"missing option for -scope"));
		Tcl_SetErrorCode(interp, "TCL", "ARGUMENT", "MISSING",
			(char *)NULL);
		return TCL_ERROR;
	    }
	    if (*scopePtr != SCOPE_NONE) {
		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
			"-scope option provided twice"));
		Tcl_SetErrorCode(interp, "TCL", "ARGUMENT", "DOUBLED",
			(char *)NULL);
		return TCL_ERROR;
	    }
	    if (Tcl_GetIndexFromObj(interp, objv[i], scopes, "scope", 0,
		    scopePtr) != TCL_OK) {
		return TCL_ERROR;
	    }
	    break;
	}
    }

    /*
     * Handle interlocking between features: -scope disables much.
     */
    if (*scopePtr != SCOPE_NONE) {
	*recursePtr = 0;
	switch (*scopePtr) {
	case SCOPE_PRIVATE:
	    *flagPtr = TRUE_PRIVATE_METHOD;
	    break;
	case SCOPE_PUBLIC:
	    *flagPtr = PUBLIC_METHOD;
	    break;
#ifdef TCLOO_SUPPORT_LOCALPRIVATE_SCOPE_IN_INFO_METHODS
	case SCOPE_LOCALPRIVATE:
	    *flagPtr = PRIVATE_METHOD;
	    break;
#endif
	case SCOPE_UNEXPORTED:
	    *flagPtr = 0;
	    break;
	}
    }
    return TCL_OK;
}
/*
 * ----------------------------------------------------------------------
 *
 * InfoObjectMethodsCmd --
 *
 *	Implements [info object methods $objName ?$option ...?]
 *
 * ----------------------------------------------------------------------
 */

static int
InfoObjectMethodsCmd(
    TCL_UNUSED(void *),
    Tcl_Interp *interp,
    int objc,
    Tcl_Obj *const objv[])
{
    static const char *const options[] = {
	"-all", "-localprivate", "-private", "-scope", NULL
    };
    enum Options {
	OPT_ALL, OPT_LOCALPRIVATE, OPT_PRIVATE, OPT_SCOPE
    } idx;
    static const char *const scopes[] = {
	"private", "public", "unexported"
    };
    enum Scopes {
	SCOPE_PRIVATE, SCOPE_PUBLIC, SCOPE_UNEXPORTED,
	SCOPE_LOCALPRIVATE,
	SCOPE_NONE = -1
    };
    Object *oPtr;
    int flag = PUBLIC_METHOD, recurse = 0, scope = SCOPE_NONE;
    int flag, recurse, scope;
    FOREACH_HASH_DECLS;
    Tcl_Obj *namePtr, *resultObj;
    Method *mPtr;

    if (objc < 2) {
	Tcl_WrongNumArgs(interp, 1, objv, "objName ?-option value ...?");
	return TCL_ERROR;
    }
    oPtr = (Object *) Tcl_GetObjectFromObj(interp, objv[1]);
    if (oPtr == NULL) {
	return TCL_ERROR;
    }
    if (objc != 2) {
	int i;

    if (ParseMethodsArgs(interp, objc, objv,
	for (i=2 ; i<objc ; i++) {
	    if (Tcl_GetIndexFromObj(interp, objv[i], options, "option", 0,
		    &idx) != TCL_OK) {
		return TCL_ERROR;
	    }
	    switch (idx) {
	    case OPT_ALL:
		recurse = 1;
		break;
	    case OPT_LOCALPRIVATE:
		flag = PRIVATE_METHOD;
		break;
	    case OPT_PRIVATE:
		flag = 0;
		break;
	    case OPT_SCOPE:
		if (++i >= objc) {
		    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
			    "missing option for -scope"));
		    Tcl_SetErrorCode(interp, "TCL", "ARGUMENT", "MISSING",
			    (char *)NULL);
		    return TCL_ERROR;
		}
		if (Tcl_GetIndexFromObj(interp, objv[i], scopes, "scope", 0,
			&scope) != TCL_OK) {
		    return TCL_ERROR;
		}
	    &recurse, &flag, &scope) != TCL_OK) {
	return TCL_ERROR;
    }
		break;
	    }

	}
    }
    if (scope != SCOPE_NONE) {
	recurse = 0;
	switch (scope) {
	case SCOPE_PRIVATE:
	    flag = TRUE_PRIVATE_METHOD;
	    break;
	case SCOPE_PUBLIC:
	    flag = PUBLIC_METHOD;
	    break;
	case SCOPE_LOCALPRIVATE:
	    flag = PRIVATE_METHOD;
	    break;
	case SCOPE_UNEXPORTED:
	    flag = 0;
	    break;
	}
    }

    TclNewObj(resultObj);
    if (recurse) {
	const char **names;
	int i, numNames = TclOOGetSortedMethodList(oPtr, NULL, NULL, flag,
	Tcl_Obj **names;
	int numNames = TclOOGetSortedMethodList(oPtr, NULL, NULL, flag,
		&names);

	for (i=0 ; i<numNames ; i++) {
	    Tcl_ListObjAppendElement(NULL, resultObj,
		    Tcl_NewStringObj(names[i], TCL_AUTO_LENGTH));
	}
	if (numNames > 0) {
	    Tcl_SetObjResult(interp, Tcl_NewListObj(numNames, names));
	    Tcl_Free((void *)names);
	    Tcl_Free((void *) names);
	}
    } else if (oPtr->methodsPtr) {
	FOREACH_HASH_DECLS;
	Tcl_Obj *namePtr, *resultObj;
	Method *mPtr;

	/*
	 * Can't pre-allocate the list buffer; not sure how many elements there
	 * are going to be yet.
	 */
	TclNewObj(resultObj);
	if (scope == SCOPE_NONE) {
	    /*
	     * Handle legacy-mode matching. [Bug 36e5517a6850]
	     */
	    int scopeFilter = flag | TRUE_PRIVATE_METHOD;

	    FOREACH_HASH(namePtr, mPtr, oPtr->methodsPtr) {
		if (mPtr->typePtr && (mPtr->flags & scopeFilter) == flag) {
		    Tcl_ListObjAppendElement(NULL, resultObj, namePtr);
		}
	    }
	} else {
	    FOREACH_HASH(namePtr, mPtr, oPtr->methodsPtr) {
		if (mPtr->typePtr && (mPtr->flags & SCOPE_FLAGS) == flag) {
		    Tcl_ListObjAppendElement(NULL, resultObj, namePtr);
		}
	    }
	}
    }
    Tcl_SetObjResult(interp, resultObj);
	Tcl_SetObjResult(interp, resultObj);
    }
    return TCL_OK;
}

/*
 * ----------------------------------------------------------------------
 *
 * InfoObjectMethodTypeCmd --
︙
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391

1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403

1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430



1431
1432

1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453


1454
1455
1456
1457
1458
1459

1460
1461
1462


1463
1464

1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484


1485
1486
1487
1488
1489
1490
1491

1419
1420
1421
1422
1423
1424
1425
















1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436



1437



























1438
1439
1440


1441


















1442


1443
1444
1445




1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473


1474
1475
1476
1477
1478
1479
1480
1481
1482








-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-

+









-
-
-
+
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
-
-
+
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-

-
-
+
+

-
-
-
-

+



+
+


+


















-
-
+
+








static int
InfoClassMethodsCmd(
    TCL_UNUSED(void *),
    Tcl_Interp *interp,
    int objc,
    Tcl_Obj *const objv[])
{
    static const char *const options[] = {
	"-all", "-localprivate", "-private", "-scope", NULL
    };
    enum Options {
	OPT_ALL, OPT_LOCALPRIVATE, OPT_PRIVATE, OPT_SCOPE
    } idx;
    static const char *const scopes[] = {
	"private", "public", "unexported"
    };
    enum Scopes {
	SCOPE_PRIVATE, SCOPE_PUBLIC, SCOPE_UNEXPORTED,
	SCOPE_NONE = -1
    };
    int flag = PUBLIC_METHOD, recurse = 0, scope = SCOPE_NONE;
    Tcl_Obj *namePtr, *resultObj;
    Method *mPtr;
    Class *clsPtr;
    int flag, recurse, scope;

    if (objc < 2) {
	Tcl_WrongNumArgs(interp, 1, objv, "className ?-option value ...?");
	return TCL_ERROR;
    }
    clsPtr = GetClassFromObj(interp, objv[1]);
    if (clsPtr == NULL) {
	return TCL_ERROR;
    }
    if (objc != 2) {
	int i;

    if (ParseMethodsArgs(interp, objc, objv,
	for (i=2 ; i<objc ; i++) {
	    if (Tcl_GetIndexFromObj(interp, objv[i], options, "option", 0,
		    &idx) != TCL_OK) {
		return TCL_ERROR;
	    }
	    switch (idx) {
	    case OPT_ALL:
		recurse = 1;
		break;
	    case OPT_LOCALPRIVATE:
		flag = PRIVATE_METHOD;
		break;
	    case OPT_PRIVATE:
		flag = 0;
		break;
	    case OPT_SCOPE:
		if (++i >= objc) {
		    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
			    "missing option for -scope"));
		    Tcl_SetErrorCode(interp, "TCL", "ARGUMENT", "MISSING",
			    (char *)NULL);
		    return TCL_ERROR;
		}
		if (Tcl_GetIndexFromObj(interp, objv[i], scopes, "scope", 0,
			&scope) != TCL_OK) {
		    return TCL_ERROR;
		}
	    &recurse, &flag, &scope) != TCL_OK) {
	return TCL_ERROR;
    }
		break;
	    }

	}
    }
    if (scope != SCOPE_NONE) {
	recurse = 0;
	switch (scope) {
	case SCOPE_PRIVATE:
	    flag = TRUE_PRIVATE_METHOD;
	    break;
	case SCOPE_PUBLIC:
	    flag = PUBLIC_METHOD;
	    break;
	case SCOPE_UNEXPORTED:
	    flag = 0;
	    break;
	}
    }

    TclNewObj(resultObj);
    if (recurse) {
	const char **names;
	Tcl_Size i, numNames = TclOOGetSortedClassMethodList(clsPtr, flag, &names);
	Tcl_Obj **names;
	Tcl_Size numNames = TclOOGetSortedClassMethodList(clsPtr, flag, &names);

	for (i=0 ; i<numNames ; i++) {
	    Tcl_ListObjAppendElement(NULL, resultObj,
		    Tcl_NewStringObj(names[i], TCL_AUTO_LENGTH));
	}
	if (numNames > 0) {
	    Tcl_SetObjResult(interp, Tcl_NewListObj(numNames, names));
	    Tcl_Free((void *)names);
	}
    } else {
	Tcl_Obj *namePtr, *resultObj;
	Method *mPtr;
	FOREACH_HASH_DECLS;

	TclNewObj(resultObj);
	if (scope == SCOPE_NONE) {
	    /*
	     * Handle legacy-mode matching. [Bug 36e5517a6850]
	     */
	    int scopeFilter = flag | TRUE_PRIVATE_METHOD;

	    FOREACH_HASH(namePtr, mPtr, &clsPtr->classMethods) {
		if (mPtr->typePtr && (mPtr->flags & scopeFilter) == flag) {
		    Tcl_ListObjAppendElement(NULL, resultObj, namePtr);
		}
	    }
	} else {
	    FOREACH_HASH(namePtr, mPtr, &clsPtr->classMethods) {
		if (mPtr->typePtr && (mPtr->flags & SCOPE_FLAGS) == flag) {
		    Tcl_ListObjAppendElement(NULL, resultObj, namePtr);
		}
	    }
	}
    }
    Tcl_SetObjResult(interp, resultObj);
	Tcl_SetObjResult(interp, resultObj);
    }
    return TCL_OK;
}

/*
 * ----------------------------------------------------------------------
 *
 * InfoClassMethodTypeCmd --
︙
This page was created in about 0.025s by Fossil version [1205ec86cb] 2025-04-30 16:57:32