Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdegames@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 172 insertions, 0 deletions

diff --git a/kpat/freecell-solver/move.h b/kpat/freecell-solver/move.h
new file mode 100644
index 00000000..a7501788
--- /dev/null
+++ b/kpat/freecell-solver/move.h
@@ -0,0 +1,172 @@
+/*
+ * move.h - header file for the move and move stacks functions of
+ * Freecell Solver
+ *
+ * Written by Shlomi Fish (shlomif@vipe.technion.ac.il), 2000
+ *
+ * This file is in the public domain (it's uncopyrighted).
+ */
+
+#ifndef FC_SOLVE__MOVE_H
+#define FC_SOLVE__MOVE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * This include is done to prevent a warning in case stdlib.h defines
+ * max. (which is the case for the Microsoft C Compiler)
+ * */
+#include <stdlib.h>
+
+#include "state.h"
+#include "fcs_move.h"
+
+
+#if 0
+fcs_move_stack_t * fcs_move_stack_create(void);
+int fcs_move_stack_push(fcs_move_stack_t * stack, fcs_move_t move);
+#endif
+
+#define fcs_move_stack_pop(stack,move) (freecell_solver_move_stack_pop(stack,move))
+extern int freecell_solver_move_stack_pop(fcs_move_stack_t * stack, fcs_move_t * move);
+
+#if 0
+void fcs_move_stack_destroy(fcs_move_stack_t * stack);
+#endif
+
+#define fcs_move_stack_destroy(stack) \
+{     \
+    free((stack)->moves);  \
+    free(stack); \
+}
+
+extern void freecell_solver_move_stack_swallow_stack(fcs_move_stack_t * stack, fcs_move_stack_t * src_stack);
+#if 0
+void fcs_move_stack_reset(fcs_move_stack_t * stack);
+#endif
+#define fcs_move_stack_reset(stack) \
+{      \
+    (stack)->num_moves = 0;   \
+}
+
+
+
+#define fcs_move_stack_get_num_moves(stack) (freecell_solver_move_stack_get_num_moves(stack))
+extern int freecell_solver_move_stack_get_num_moves(fcs_move_stack_t * stack);
+
+#if 0
+fcs_move_stack_t * fcs_move_stack_duplicate(fcs_move_stack_t * stack);
+#endif
+#define fcs_move_stack_duplicate_into_var(final_ret,stack) \
+{        \
+    fcs_move_stack_t * ret;     \
+    fcs_move_stack_t * temp_stack=(stack) ; \
+           \
+    ret = (fcs_move_stack_t *)malloc(sizeof(fcs_move_stack_t));     \
+                 \
+    ret->max_num_moves = temp_stack->max_num_moves;      \
+    ret->num_moves = temp_stack->num_moves;         \
+    ret->moves = (fcs_move_t *)malloc(sizeof(fcs_move_t) * ret->max_num_moves);     \
+    memcpy(ret->moves, temp_stack->moves, sizeof(fcs_move_t) * ret->max_num_moves);    \
+        \
+    (final_ret) = ret;       \
+}
+
+
+
+void freecell_solver_apply_move(fcs_state_with_locations_t * state_with_locations, fcs_move_t move, int freecells_num, int stacks_num, int decks_num);
+
+void freecell_solver_move_stack_normalize(
+    fcs_move_stack_t * moves,
+    fcs_state_with_locations_t * init_state,
+    int freecells_num,
+    int stacks_num,
+    int decks_num
+    );
+
+extern char * freecell_solver_move_to_string(fcs_move_t move, int standard_notation);
+
+extern char * freecell_solver_move_to_string_w_state(fcs_state_with_locations_t * state, int freecells_num, int stacks_num, int decks_num, fcs_move_t move, int standard_notation);
+
+struct fcs_derived_states_list_struct
+{
+    int num_states;
+    int max_num_states;
+    fcs_state_with_locations_t * * states;
+};
+
+typedef struct fcs_derived_states_list_struct fcs_derived_states_list_t;
+
+#if 0
+extern void fcs_derived_states_list_add_state(
+    fcs_derived_states_list_t * list,
+    fcs_state_with_locations_t * state,
+    fcs_move_stack_t * move_stack
+    );
+#endif
+
+#ifndef max
+#define max(a,b) (((a)>(b))?(a):(b))
+#endif
+
+#define FCS_MOVE_STACK_GROW_BY 16
+
+/* This macro allocates an empty move stack */
+#define fcs_move_stack_alloc_into_var(final_ret) \
+{       \
+    fcs_move_stack_t * ret; \
+        \
+    /* Allocate the data structure itself */      \
+    ret = (fcs_move_stack_t *)malloc(sizeof(fcs_move_stack_t));    \
+       \
+    ret->max_num_moves = FCS_MOVE_STACK_GROW_BY;      \
+    ret->num_moves = 0;        \
+    /* Allocate some space for the moves */     \
+    ret->moves = (fcs_move_t *)malloc(sizeof(fcs_move_t)*ret->max_num_moves);  \
+                \
+    (final_ret) = ret;       \
+}
+
+
+#define fcs_move_stack_push(stack, move) \
+{           \
+    /* If all the moves inside the stack are taken then    \
+       resize the move vector */       \
+              \
+    if (stack->num_moves == stack->max_num_moves) \
+    {      \
+        int a, b;   \
+        a = (stack->max_num_moves >> 3);      \
+        b = FCS_MOVE_STACK_GROW_BY;    \
+        stack->max_num_moves += max(a,b);    \
+        stack->moves = realloc(     \
+            stack->moves,     \
+            stack->max_num_moves * sizeof(fcs_move_t)   \
+            );     \
+    }       \
+    stack->moves[stack->num_moves++] = move;    \
+            \
+}
+
+#define fcs_derived_states_list_add_state(list,state) \
+    \
+{       \
+    if ((list)->num_states == (list)->max_num_states)  \
+    {        \
+        (list)->max_num_states += 16;     \
+        (list)->states = realloc((list)->states, sizeof((list)->states[0]) * (list)->max_num_states); \
+    }        \
+    (list)->states[(list)->num_states] = (state);    \
+    (list)->num_states++;        \
+}
+
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /* FC_SOLVE__MOVE_H */