Rename functions and enums

Author: andy5995

SWIG_INTERFACE.md

@@ -30,10 +30,10 @@ deckhandler.seed()
 deck = deckhandler.get_new_deck()
 
 # Shuffle the deck.
-deckhandler.dh_shuffle_deck(deck)
+deckhandler.DH_shuffle_deck(deck)
 
 # Print out the whole deck.
-for i in range(deckhandler.CARDS_IN_DECK):
+for i in range(deckhandler.DH_CARDS_IN_DECK):
     card = deckhandler.deck_dh_get(deck, i)
     print("face: {}, suit: {}".format(deckhandler.DH_get_card_face(card), deckhandler.DH_get_card_suit(card)))
 ```

deckhandler.c

@@ -38,45 +38,45 @@
 
 static pcg32_random_t rng;
 
-static const char *dh_suits[] = {"Hearts  ", "Diamonds", "Spades  ", "Clubs   "};
+static const char *suits[] = {"Hearts  ", "Diamonds", "Spades  ", "Clubs   "};
 
-static const char *dh_faces[] = {"Ace", "2", "3",  "4",    "5",     "6",   "7",
+static const char *faces[] = {"Ace", "2", "3",  "4",    "5",     "6",   "7",
                                  "8",   "9", "10", "Jack", "Queen", "King"};
 
-const DH_Card dh_card_back = {
+const DH_Card DH_card_back = {
     .face_val = -1,
     .suit = -1,
 };
 
-const DH_Card dh_card_null = {
+const DH_Card DH_card_null = {
     .face_val = -2,
     .suit = -2,
 };
 
-void dh_pcg_srand(uint64_t initstate, uint64_t initseq) {
+void DH_pcg_srand(uint64_t initstate, uint64_t initseq) {
   pcg32_srandom_r(&rng, initstate, initseq);
   return;
 }
 
-void dh_pcg_srand_auto(void) {
+void DH_pcg_srand_auto(void) {
   uint64_t initstate = time(NULL) ^ (intptr_t)&printf;
-  uint64_t initseq = (intptr_t)&dh_faces;
+  uint64_t initseq = (intptr_t)&faces;
   pcg32_srandom_r(&rng, initstate, initseq);
 }
 
-static void dh_init_deck(DH_Deck *deck) {
+static void DH_init_deck(DH_Deck *deck) {
   deck->top_card = 0;
 
   int card = 0;
   int suit = 0;
-  int face = ACE;
+  int face = DH_CARD_ACE;
 
-  while (suit < MAX_SUITS) {
+  while (suit < DH_SUIT_MAX) {
     deck->card[card].face_val = face++;
     deck->card[card].suit = suit;
 
-    if (face > KING) {
-      face = ACE;
+    if (face > DH_CARD_KING) {
+      face = DH_CARD_ACE;
       suit++;
     }
 
@@ -85,14 +85,14 @@ static void dh_init_deck(DH_Deck *deck) {
   return;
 }
 
-DH_Deck dh_get_new_deck(void) {
+DH_Deck DH_get_new_deck(void) {
   DH_Deck deck;
-  dh_init_deck(&deck);
+  DH_init_deck(&deck);
   return deck;
 }
 
-DH_Card dh_deal_top_card(DH_Deck *deck) {
-  if (deck->top_card == CARDS_IN_DECK) {
+DH_Card DH_deal_top_card(DH_Deck *deck) {
+  if (deck->top_card == DH_CARDS_IN_DECK) {
     deck->top_card = 0;
     puts("deckhandler: deck wrapped");
   }
@@ -107,27 +107,27 @@ static void swap(DH_Deck *deck_dh, int i, int j) {
   deck_dh->card[j] = tmp;
 }
 
-void dh_shuffle_deck(DH_Deck *deck) {
-  for (int i = CARDS_IN_DECK - 1; i > 0; --i) {
+void DH_shuffle_deck(DH_Deck *deck) {
+  for (int i = DH_CARDS_IN_DECK - 1; i > 0; --i) {
     int j = pcg32_boundedrand_r(&rng, i + 1);
     swap(deck, i, j);
   }
   deck->top_card = 0;
 }
 
-const char *DH_get_card_face(DH_Card card) { return dh_faces[card.face_val - 1]; }
+const char *DH_get_card_face(DH_Card card) { return faces[card.face_val - 1]; }
 
-const char *DH_get_card_suit(DH_Card card) { return dh_suits[card.suit]; }
+const char *DH_get_card_suit(DH_Card card) { return suits[card.suit]; }
 
 const char *DH_get_card_unicode_suit(DH_Card card) {
   switch (card.suit) {
-  case DIAMONDS:
+  case DH_SUIT_DIAMONDS:
     return "\u2666";
-  case HEARTS:
+  case DH_SUIT_HEARTS:
     return "\u2665";
-  case SPADES:
+  case DH_SUIT_SPADES:
     return "\u2660";
-  case CLUBS:
+  case DH_SUIT_CLUBS:
     return "\u2663";
   default:
     return "?";

deckhandler.h

@@ -24,33 +24,33 @@ extern "C" {
 
 /// Enumeration of the four standard card suits.
 enum {
-  HEARTS,   ///< Hearts suit
-  DIAMONDS, ///< Diamonds suit
-  SPADES,   ///< Spades suit
-  CLUBS,    ///< Clubs suit
-  MAX_SUITS ///< Number of suits
+  DH_SUIT_HEARTS,   ///< Hearts suit
+  DH_SUIT_DIAMONDS, ///< Diamonds suit
+  DH_SUIT_SPADES,   ///< Spades suit
+  DH_SUIT_CLUBS,    ///< Clubs suit
+  DH_SUIT_MAX ///< Number of suits
 };
 
 /// Enumeration of card face values (Ace can be high or low).
 enum card_face {
-  ACE = 1, ///< Ace (low)
-  TWO,
-  THREE,
-  FOUR,
-  FIVE,
-  SIX,
-  SEVEN,
-  EIGHT,
-  NINE,
-  TEN,
-  JACK,
-  QUEEN,
-  KING,
-  ACE_HIGH ///< Ace (high) for straight evaluation, not dealt
+  DH_CARD_ACE = 1, ///< Ace (low)
+  DH_CARD_TWO,
+  DH_CARD_THREE,
+  DH_CARD_FOUR,
+  DH_CARD_FIVE,
+  DH_CARD_SIX,
+  DH_CARD_SEVEN,
+  DH_CARD_EIGHT,
+  DH_CARD_NINE,
+  DH_CARD_TEN,
+  DH_CARD_JACK,
+  DH_CARD_QUEEN,
+  DH_CARD_KING,
+  DH_CARD_ACE_HIGH ///< Ace (high) for straight evaluation, not dealt
 };
 
 /// Total number of cards in a standard deck.
-#define CARDS_IN_DECK 52
+#define DH_CARDS_IN_DECK 52
 
 /**
  * @DH_Card
@@ -61,15 +61,15 @@ typedef struct {
   int suit;     ///< Suit of the card (see enum)
 } DH_Card;
 
-extern const DH_Card dh_card_back;
-extern const DH_Card dh_card_null;
+extern const DH_Card DH_card_back;
+extern const DH_Card DH_card_null;
 
 /**
  * @DH_Deck
  * @brief Represents a full deck of 52 playing cards.
  */
 typedef struct  {
-  DH_Card card[CARDS_IN_DECK]; ///< Array of all cards in the deck
+  DH_Card card[DH_CARDS_IN_DECK]; ///< Array of all cards in the deck
   int top_card;
 } DH_Deck;
 
@@ -79,43 +79,43 @@ typedef struct  {
  * @param initstate Initialization state value.
  * @param initseq   Initialization sequence value.
  */
-void dh_pcg_srand(uint64_t initstate, uint64_t initseq);
+void DH_pcg_srand(uint64_t initstate, uint64_t initseq);
 
 /**
  * @brief Automatically seed the PCG random number generator with internal defaults.
  *
  * Uses `time(NULL)` and pointer values for entropy.
  */
-void dh_pcg_srand_auto(void);
+void DH_pcg_srand_auto(void);
 
 /**
  * @brief Create and initialize a new deck of cards.
  *
  * This function returns a new `dh_deck` struct that is initialized to a full, shuffled deck.
- * Internally, it calls `dh_init_deck()` to perform the initialization.
+ * Internally, it calls `DH_init_deck()` to perform the initialization.
  *
  * @return A fully initialized deck of cards.
  */
-DH_Deck dh_get_new_deck(void);
+DH_Deck DH_get_new_deck(void);
 
 /**
  * @brief Deal the top card from the deck.
  *
  * Deals the card currently at the top of the deck and advances the deck position.
- * If all cards have been dealt (`top_card == CARDS_IN_DECK`), the deck wraps and begins from the
+ * If all cards have been dealt (`top_card == DH_CARDS_IN_DECK`), the deck wraps and begins from the
  * top again, resetting `top_card` to 0 and printing a warning message.
  *
  * @param deck Pointer to the deck from which to deal a card.
  * @return The card at the current top position of the deck.
  */
-DH_Card dh_deal_top_card(DH_Deck *deck);
+DH_Card DH_deal_top_card(DH_Deck *deck);
 
 /**
  * @brief Shuffle a deck of cards using the PCG random number generator.
  *
  * @param deck_dh Pointer to the deck to shuffle.
  */
-void dh_shuffle_deck(DH_Deck *deck_dh);
+void DH_shuffle_deck(DH_Deck *deck_dh);
 
 /**
  * @brief Get the string name of a card's face value (e.g., "Ace", "10", "King").

swig/deckhandler.i

@@ -20,6 +20,6 @@ deck_dh_get(DH_Deck deck, int i) {
 
 void
 seed(void) {
-  dh_pcg_srand_auto();
+  DH_pcg_srand_auto();
 }
 %}

test/test_01.c

@@ -37,57 +37,57 @@ int main(int argc, char *argv[]) {
   (void)argc;
   (void)argv;
   /* declare a deck using type "DH_Deck" (defined in deckhandler.h) */
-  DH_Deck deck_a = dh_get_new_deck();
+  DH_Deck deck_a = DH_get_new_deck();
 
   int deals_num = 0;
   int deals_max = 3;
 
-  dh_pcg_srand(1, 1);
+  DH_pcg_srand(1, 1);
 
   do {
     /* shuffle the deck */
     puts("\n\n\t]=[ Shuffling ]=[\n");
-    dh_shuffle_deck(&deck_a);
+    DH_shuffle_deck(&deck_a);
 
     /* show each card in the deck */
     int deal;
-    for (deal = 0; deal < CARDS_IN_DECK; deal++) {
+    for (deal = 0; deal < DH_CARDS_IN_DECK; deal++) {
       /* The "faces" and "suits" arrays are initialized in deckhandler.c */
       // fprintf (stderr, "%s of %s\n", DH_get_card_face(deck_a.card[deal]),
       // DH_get_card_suit(deck_a.card[deal]));
-      DH_Card card = dh_deal_top_card(&deck_a);
+      DH_Card card = DH_deal_top_card(&deck_a);
       fprintf(stderr, "%i\n", card.face_val);
       if (deal < 4 && deals_num == 0) {
         switch (deal) {
         case 0:
-          assert(card.face_val == TWO);
+          assert(card.face_val == DH_CARD_TWO);
           break;
         case 1:
-          assert(card.face_val == FIVE);
+          assert(card.face_val == DH_CARD_FIVE);
           break;
         case 2:
-          assert(card.face_val == FIVE);
+          assert(card.face_val == DH_CARD_FIVE);
           break;
         case 3:
-          assert(card.face_val == FIVE);
+          assert(card.face_val == DH_CARD_FIVE);
           break;
         case 4:
-          assert(card.face_val == QUEEN);
+          assert(card.face_val == DH_CARD_QUEEN);
           break;
         case 5:
-          assert(card.face_val == JACK);
+          assert(card.face_val == DH_CARD_JACK);
           break;
         case 6:
-          assert(card.face_val == KING);
+          assert(card.face_val == DH_CARD_KING);
           break;
         case 7:
-          assert(card.face_val == SIX);
+          assert(card.face_val == DH_CARD_SIX);
           break;
         case 8:
-          assert(card.face_val == NINE);
+          assert(card.face_val == DH_CARD_NINE);
           break;
         case 9:
-          assert(card.face_val == THREE);
+          assert(card.face_val == DH_CARD_THREE);
           break;
         }
       }
@@ -98,31 +98,31 @@ int main(int argc, char *argv[]) {
   int total_decks = 4;
   DH_Deck deck_num[total_decks];
   for (int i = 0; i < total_decks; i++)
-    deck_num[i] = dh_get_new_deck();
+    deck_num[i] = DH_get_new_deck();
 
   int which_deck;
   for (which_deck = 0; which_deck < total_decks; which_deck++)
-    dh_shuffle_deck(&deck_num[which_deck]);
+    DH_shuffle_deck(&deck_num[which_deck]);
 
   /* There's no function in the library (yet) that shuffles multiple decks
    * together, but using the method below will provide a close simulation */
-  for (int i = 0; i < CARDS_IN_DECK; i++) {
+  for (int i = 0; i < DH_CARDS_IN_DECK; i++) {
     for (which_deck = 0; which_deck < total_decks; which_deck++) {
-      DH_Card card = dh_deal_top_card(&deck_num[which_deck]);
+      DH_Card card = DH_deal_top_card(&deck_num[which_deck]);
       printf("%s of %s\n", DH_get_card_face(card), DH_get_card_suit(card));
-      if (i == CARDS_IN_DECK - 1) {
+      if (i == DH_CARDS_IN_DECK - 1) {
         switch (which_deck) {
         case 0:
-          assert(card.face_val == TEN);
+          assert(card.face_val == DH_CARD_TEN);
           break;
         case 1:
-          assert(card.face_val == TWO);
+          assert(card.face_val == DH_CARD_TWO);
           break;
         case 2:
-          assert(card.face_val == THREE);
+          assert(card.face_val == DH_CARD_THREE);
           break;
         case 3:
-          assert(card.face_val == ACE);
+          assert(card.face_val == DH_CARD_ACE);
           break;
         }
       }