Plugins

int mba_PlusA_1 (int x, int y) {
  return (x|y)+(x&y);
}

int mba_PlusA_2 (int x, int y) {
  return x− ~y −1;
}

long mba_PlusA_3 (long x, long y) {
  return x− ~y −1;
}

int mba_BXor (int x, int y) {
   return (x|y)–(x&y);
}

int highScore = 0;     /* Always less than 100! */
...
int acme_RANGE_0_99 (void) {
   return highScore;
}

tigress \
           --Transform=InitPlugins  --InitPluginsInvariantPrefix=acme    \
           --Transform=InitOpaque --Functions=main --InitOpaqueStructs=plugin    \
           --Transform=AddOpaque \
              --Functions=* \
              --AddOpaqueKinds=true \
              --AddOpaqueStructs=plugin	\

/* Returns a random value */
int acme_ANY (void) {
   return list_length(myList);
}

/* Returns 42. */
int acme_VALUE_42 (void) {
   return aes_key[4];
}

/* Returns 5. */
int acme_VALUE_5 (void) {
   return 5;
}

/* Returns 5, assuming the program is supposed to always be called with 5 arguments. */
/* Note the use of the extra _ to disambiguate from the previous function. */
int acme_VALUE_5_ (int argc) {
   return argc;
}

/* Returns a value in [10..]. */
int acme_MIN_10 () {
   return 10 + random();
}

/* Returns a value in [..10]. */
int acme_MAX_10 () {
   return (random() % 11);
}

/* Returns a value in [10..20]. */
int acme_RANGE_10_20 () {
   return 10 + (random() % 11);
}

/* Returns the length of the argument list, for a program
   that is expected to be called with 1,2, or 3 arguments . */
int acme_RANGE_1_3 (int argc) {
   return argc;
}

tigress \
         --Transform=InitPlugins  --InitPluginsResponderPrefix=acme_responder    \
         --Transform=Checksum ... --ChecksumResponseKinds=plugin ... \
         ...

void acme_responder_1 () {
   abort();
}
void acme_responder_2 (int argc, char** argv) {
   argv[argc-1] = '\0';
}
void acme_responder_3 () {
   for(int i=0; i<10; i++) {
      printf("Hacked %i!\n", i);
   }
   exit(-1);
}
void acme_responder_4 () {
   phone_home("We've been hacked!");
}

void acme_responder_5 () {
   memset(aes_key, 0, 16);
}

int alwaysEven;

void acme_initialize_even (int argc) {
   alwaysEven = (argc+1) * 2;
}

void acme_update_even_1 () {
   alwaysEven += 2;
}

void acme_update_even_2 (int f) {
   alwaysEven += f + (f % 2);
}

int acme_invariant_even_VALUE_0 (void) {
   return alwaysEven%2;
}

tigress  ... \
     --Transform=InitPlugins  \
        --InitPluginsInvariantPrefix=acme_invariant    \
        --InitPluginsInitializePrefix=acme_initialize    \
        --InitPluginsUpdatePrefix=acme_update    \
     --Transform=InitOpaque   \
         --Functions=main \
          --InitOpaqueStructs=plugin    \
     --Transform=AddOpaque \
        --Functions=* \
        --AddOpaqueKinds=true \
        --AddOpaqueStructs=plugin \
     --Transform=UpdateOpaque \
        --Functions=* \
        --UpdateOpaqueCount=10 

typedef struct intList {
   struct intListNode* first;
} *INTLIST;

typedef struct intListNode {
   int value;
   struct intListNode* next;
} *INTLISTNODE;

typedef INTLIST intList_t;
typedef INTLISTNODE intListNode_t;

intList_t list;

void acme_initialize_list (int argc) {
   list = (intList_t) malloc(sizeof(struct intList));
   list->first = NULL;
   for(int i=0; i < (argc * 2); i++) {
      intListNode_t r = (intListNode_t) malloc(sizeof(struct intListNode));
      r->value = i*2+1;
      r->next = list->first;
      list->first = r;
   }
}

void acme_update_list (int v1, int v2) {
   intListNode_t r = (intListNode_t) malloc(sizeof(struct intListNode));
   r->value = v1*2+1;
   r->next = list->first;
   list->first = r;
   r = (intListNode_t) malloc(sizeof(struct intListNode));
   r->value = v2*4+1;
   r->next = list->first;
   list->first = r;
}

int acme_invariant_length_VALUE_0 () {
   int length = 0;
   intListNode_t i = list->first;
   while (i != NULL) {
     length++;
     i = i->next;
   };
   return length % 2;
}

int acme_invariant_odd_VALUE_0 (int v) {
   int value = 3;
   intListNode_t i = list->first;
   int times = v;
   while ((i != NULL) && (times > 0)) {
     value = i->value;
     times--;
     i = i->next;
   };
   return value % 2 - 1;
}

   --Transform=InitPlugins \
       --InitPluginsCollectionPrefix=Set \
       --InitPluginsDictionaryPrefix=HashMap

// Types for Sets.
typedef ... Set_TYPE;
typedef ... Set_ELEMENT;
typedef ... Set_ITER;

// Create and destroy a set
Set_TYPE Set_CREATE(){ ... }
void Set_DESTROY(Set_TYPE *a) { ... }

// Merge sets in different ways (union, intersection, etc). 
Set_TYPE Set_JOIN_union(Set_TYPE a, Set_TYPE b) { ... } 
Set_TYPE Set_JOIN_diff(Set_TYPE a, Set_TYPE b){ ... }

// Insert and delete elements from the set.
void Set_INSERT(Set_TYPE a, Set_ELEMENT b) { ... }
void Set_DELETE(Set_TYPE a, Set_ELEMENT b) { ... }

// Query the set
int Set_MEMBER(Set_TYPE a, Set_ELEMENT b){ ... }
int Set_SIZE(Set_TYPE a){ ... }

// Iterate through the elements of the set. Here's the pattern to use:
// Set_ITER i = Set_FIRST(s);
// while not Set_DONE(s, i) {
//   Set_ELEMENT e = Set_GET(s,i);
//   Do something with e;
//   i = Set_NEXT(s,i);
// }
Set_ITER Set_FIRST(Set_TYPE a){ ... }
Set_ITER Set_NEXT(Set_TYPE a, Set_ITER n){ ... }
int Set_DONE(Set_TYPE a, Set_ITER n){ ... }
Set_ELEMENT Set_GET(Set_TYPE a, Set_ITER n){ ... }

// Similar for HashMaps (instances of a Dictionary ADT).
typedef ... HashMap_TYPE;
typedef ... HashMap_KEY;
typedef ... HashMap_ELEMENT;
typedef ... HashMap_ITER;

HashMap_TYPE HashMap_CREATE(){ ... }
void HashMap_INSERT(HashMap_TYPE a, HashMap_KEY b, HashMap_ELEMENT c) { ... }
void HashMap_DELETE(HashMap_TYPE a, HashMap_KEY b) { ... }
int HashMap_MEMBER(HashMap_TYPE a, HashMap_KEY b){ ... }
HashMap_ELEMENT HashMap_LOOKUP(HashMap_TYPE a, HashMap_KEY b){ ... }
void HashMap_DESTROY(HashMap_TYPE *a) { ... }
int HashMap_SIZE(Set_TYPE a){ ... }
HashMap_KEY HashMap_NTH(Set_TYPE a, int n){ ... }
HashMap_ITER HashMap_FIRST(HashMap_TYPE a){ ... }
HashMap_ITER HashMap_NEXT(HashMap_TYPE a, HashMap_ITER n){ ... }
int HashMap_DONE(HashMap_TYPE a, HashMap_ITER n){ ... }
HashMap_ELEMENT HashMap_GET(HashMap_TYPE a, HashMap_ITER n){ ... }