From 2ef6d0360a8317b47f1a78990e2ed2f660855b53 Mon Sep 17 00:00:00 2001 From: bdemsky Date: Wed, 14 Jun 2017 16:51:13 -0700 Subject: [PATCH] switch to C --- src/Makefile | 2 +- src/boolean.h | 5 +-- src/classlist.h | 12 ++++-- src/csolver.c | 57 ++++++++++++++++---------- src/csolver.h | 52 ++++++++++++------------ src/element.c | 6 ++- src/element.h | 10 ++--- src/function.h | 5 +-- src/mutableset.c | 1 + src/mutableset.h | 5 +-- src/mymemory.h | 102 ++++------------------------------------------- src/order.c | 1 + src/order.h | 6 +-- src/predicate.h | 5 +-- src/set.c | 39 +++++++++--------- src/set.h | 20 ++++------ src/stl-model.h | 51 ------------------------ src/structs.c | 5 +++ src/structs.h | 8 ++++ src/table.h | 8 ++-- src/vector.h | 57 ++++++++++++++++++++++++++ 21 files changed, 197 insertions(+), 260 deletions(-) delete mode 100644 src/stl-model.h create mode 100644 src/structs.c create mode 100644 src/structs.h create mode 100644 src/vector.h diff --git a/src/Makefile b/src/Makefile index 548189e..dae27b7 100644 --- a/src/Makefile +++ b/src/Makefile @@ -4,7 +4,7 @@ PHONY += directories MKDIR_P = mkdir -p OBJ_DIR = bin -CPP_SOURCES := constraint.cc inc_solver.cc set.cc mutableset.cc element.cc function.cc order.cc table.cc predicate.cc boolean.cc csolver.cc +CPP_SOURCES := set.cc mutableset.cc element.cc function.cc order.cc table.cc predicate.cc boolean.cc csolver.cc structs.c OBJECTS := $(CPP_SOURCES:%.cc=$(OBJ_DIR)/%.o) $(C_SOURCES:%.c=$(OBJ_DIR)/%.o) diff --git a/src/boolean.h b/src/boolean.h index 98e727e..5e8c5a5 100644 --- a/src/boolean.h +++ b/src/boolean.h @@ -3,9 +3,6 @@ #include "classlist.h" #include "mymemory.h" -class Boolean { - public: - MEMALLOC; - private: +struct Boolean { }; #endif diff --git a/src/classlist.h b/src/classlist.h index 53555ed..c6a7cb7 100644 --- a/src/classlist.h +++ b/src/classlist.h @@ -9,9 +9,15 @@ #ifndef CLASSLIST_H #define CLASSLIST_H -#include "hashset.h" +//#include "hashset.h" #include "mymemory.h" #include +#define bool int +#define true 1 +#define false 0 + +struct CSolver; +typedef struct CSolver CSolver; struct Constraint; typedef struct Constraint Constraint; @@ -20,7 +26,7 @@ struct Boolean; typedef struct Boolean Boolean; struct IncrementalSolver; -typedef struct IncrementSolver IncrementalSolver; +typedef struct IncrementalSolver IncrementalSolver; struct Set; typedef struct Set Set; @@ -34,7 +40,7 @@ struct Function; typedef struct Function Function; struct Predicate; -typedef struct Predicat Predicate; +typedef struct Predicate Predicate; struct Table; typedef struct Table Table; diff --git a/src/csolver.c b/src/csolver.c index 20e729a..a6dde8f 100644 --- a/src/csolver.c +++ b/src/csolver.c @@ -2,64 +2,79 @@ CSolver * allocCSolver() { CSolver * tmp=(CSolver *) ourmalloc(sizeof(CSolver)); - tmp->constraint=allocVector(); + tmp->constraint=allocDefVectorBoolean(); return tmp; } -Set * createSet(CSolver * solver, Type type, uint64_t ** elements) { - +Set * createSet(CSolver * solver, VarType type, uint64_t ** elements) { + return NULL; } -Set * createSet(CSolver * solver, Type type, uint64_t lowrange, uint64_t highrange) { +Set * createRangeSet(CSolver * solver, VarType type, uint64_t lowrange, uint64_t highrange) { + return NULL; } -MutableSet * createMutableSet(CSolver * solver, Type type) { +MutableSet * createMutableSet(CSolver * solver, VarType type) { + return NULL; } -void CSolver::addItem(MutableSet * set, uint64_t element) { +void addItem(CSolver *solver, MutableSet * set, uint64_t element) { } -int64_t CSolver::createUniqueItem(MutableSet * set) { +int64_t createUniqueItem(CSolver *solver, MutableSet * set) { + return 0; } -Element * CSolver::getElementVar(Set * set) { +Element * getElementVar(CSolver *solver, Set * set) { + return NULL; } -Boolean * CSolver::getBooleanVar() { +Boolean * getBooleanVar(CSolver *solver) { + return NULL; } -Function * CSolver::createFunctionOperator(enum ArithOp op, Set ** domain, Set * range, enum OverFlowBehavior overflowbehavior, Boolean * overflowstatus) { +Function * createFunctionOperator(CSolver *solver, enum ArithOp op, Set ** domain, Set * range, enum OverFlowBehavior overflowbehavior, Boolean * overflowstatus) { + return NULL; } -Function * CSolver::createFunctionOperator(enum ArithOp op) { +Function * createFunctionOperatorPure(CSolver *solver, enum ArithOp op) { + return NULL; } -Predicate * CSolver::createPredicateOperator(enum CompOp op, Set ** domain) { +Predicate * createPredicateOperator(CSolver *solver, enum CompOp op, Set ** domain) { + return NULL; } -Table * CSolver::createTable(Set **domains, Set * range) { +Table * createTable(CSolver *solver, Set **domains, Set * range) { + return NULL; } -void CSolver::addTableEntry(Element ** inputs, Element *result) { +void addTableEntry(CSolver *solver, Element ** inputs, Element *result) { } -Function * CSolver::completeTable(struct Table *) { +Function * completeTable(CSolver *solver, Table * table) { + return NULL; } -Element * CSolver::applyFunction(Function * function, Element ** array) { +Element * applyFunction(CSolver *solver, Function * function, Element ** array) { + return NULL; } -Boolean * CSolver::applyPredicate(Predicate * predicate, Element ** inputs) { +Boolean * applyPredicate(CSolver *solver, Predicate * predicate, Element ** inputs) { + return NULL; } -Boolean * CSolver::applyLogicalOperation(enum LogicOp op, Boolean ** array) { +Boolean * applyLogicalOperation(CSolver *solver, enum LogicOp op, Boolean ** array) { + return NULL; } -void CSolver::addBoolean(Boolean * constraint) { +void addBoolean(CSolver *solver, Boolean * constraint) { } -Order * CSolver::createOrder(enum OrderType type, Set * set) { +Order * createOrder(CSolver *solver, enum OrderType type, Set * set) { + return NULL; } -Boolean * CSolver::orderedConstraint(Order * order, uint64_t first, uint64_t second) { +Boolean * orderConstraint(CSolver *solver, Order * order, uint64_t first, uint64_t second) { + return NULL; } diff --git a/src/csolver.h b/src/csolver.h index b03adb7..7b2d659 100644 --- a/src/csolver.h +++ b/src/csolver.h @@ -2,38 +2,38 @@ #define CSOLVER_H #include "classlist.h" #include "ops.h" +#include "structs.h" -class CSolver { -public: - CSolver(); - Set * createSet(Type type, uint64_t ** elements); - Set * createSet(Type type, uint64_t lowrange, uint64_t highrange); - MutableSet * createMutableSet(Type type); +struct CSolver { + VectorBoolean * constraint; +}; + +CSolver * allocCSolver(); +Set * createSet(CSolver *, VarType type, uint64_t ** elements); +Set * createRangeSet(CSolver *, VarType type, uint64_t lowrange, uint64_t highrange); +MutableSet * createMutableSet(CSolver *, VarType type); - void addItem(MutableSet * set, uint64_t element); - int64_t createUniqueItem(MutableSet * set); +void addItem(CSolver *, MutableSet * set, uint64_t element); +int64_t createUniqueItem(CSolver *, MutableSet * set); - Element * getElementVar(Set * set); - Constraint * getBooleanVar(); +Element * getElementVar(CSolver *, Set * set); +Boolean * getBooleanVar(CSolver *); - Function * createFunctionOperator(enum ArithOp op, Set ** domain, Set * range, enum OverFlowBehavior overflowbehavior, Constraint * overflowstatus); - //Does Not Overflow - Function * createFunctionOperator(enum ArithOp op); - Predicate * createPredicateOperator(enum CompOp op, Set ** domain); +Function * createFunctionOperator(CSolver *, enum ArithOp op, Set ** domain, Set * range, enum OverFlowBehavior overflowbehavior, Boolean * overflowstatus); +//Does Not Overflow +Function * createFunctionOperatorPure(CSolver *, enum ArithOp op); +Predicate * createPredicateOperator(CSolver *, enum CompOp op, Set ** domain); - Table * createTable(Set **domains, Set * range); - void addTableEntry(Element ** inputs, Element *result); - Function * completeTable(struct Table *); +Table * createTable(CSolver *, Set **domains, Set * range); +void addTableEntry(CSolver *, Element ** inputs, Element *result); +Function * completeTable(CSolver *, struct Table *); - Element * applyFunction(Function * function, Element ** array); - Constraint * applyPredicate(Predicate * predicate, Element ** inputs); - Constraint * applyLogicalOperation(enum LogicOp op, Constraint ** array); +Element * applyFunction(CSolver *, Function * function, Element ** array); +Boolean * applyPredicate(CSolver *, Predicate * predicate, Element ** inputs); +Boolean * applyLogicalOperation(CSolver *, enum LogicOp op, Boolean ** array); - void addConstraint(Constraint * constraint); +void addBoolean(CSolver *, Boolean * constraint); - Order * createOrder(enum OrderType type, Set * set); - Constraint * orderedConstraint(Order * order, uint64_t first, uint64_t second); -private: - ModelVector constraints; -}; +Order * createOrder(CSolver *, enum OrderType type, Set * set); +Boolean * orderConstraint(CSolver *, Order * order, uint64_t first, uint64_t second); #endif diff --git a/src/element.c b/src/element.c index 2b9d1e1..e9284f7 100644 --- a/src/element.c +++ b/src/element.c @@ -1,5 +1,7 @@ #include "element.h" -Element::Element(Set * s) : - set(s) { +Element *allocElement(Set * s) { + Element * tmp=(Element *)ouralloc(sizeof(Element)); + tmp->set=s; + return tmp; } diff --git a/src/element.h b/src/element.h index 2c0d1f6..06c33a0 100644 --- a/src/element.h +++ b/src/element.h @@ -3,11 +3,9 @@ #include "classlist.h" #include "mymemory.h" -class Element { -public: - Element(Set *s); - MEMALLOC; -private: - Set *set; +struct Element { + Set * set; }; + +Element * allocElement(Set *s); #endif diff --git a/src/function.h b/src/function.h index 69abc54..da5087b 100644 --- a/src/function.h +++ b/src/function.h @@ -2,10 +2,7 @@ #define FUNCTION_H #include "classlist.h" #include "mymemory.h" -class Function { -public: - MEMALLOC; -private: +struct Function { }; #endif diff --git a/src/mutableset.c b/src/mutableset.c index 76bb779..3f33f90 100644 --- a/src/mutableset.c +++ b/src/mutableset.c @@ -1,2 +1,3 @@ #include "mutableset.h" +void addElementMSet(MutableSet * set, uint64_t element) { pushVectorInt(set->members, element); } diff --git a/src/mutableset.h b/src/mutableset.h index 479f16c..eee89bb 100644 --- a/src/mutableset.h +++ b/src/mutableset.h @@ -2,8 +2,5 @@ #define MUTABLESET_H #include "set.h" -class MutableSet : Set { -public: - void addElement(uint64_t element) { members->push_back(element); } -}; +void addElementMSet(MutableSet * set, uint64_t element); #endif diff --git a/src/mymemory.h b/src/mymemory.h index d55c138..5267ce2 100644 --- a/src/mymemory.h +++ b/src/mymemory.h @@ -21,7 +21,8 @@ /** MEMALLOC declares the allocators for a class to allocate * memory in the non-snapshotting heap. */ -#define MEMALLOC \ +/* +#define MEMALLOC \ void * operator new(size_t size) { \ return model_malloc(size); \ } \ @@ -37,103 +38,16 @@ void * operator new(size_t size, void *p) { \ return p; \ } +*/ + +void * ourmalloc(size_t size); +void ourfree(void *ptr); +void * ourcalloc(size_t count, size_t size); +void * ourrealloc(void *ptr, size_t size); void *model_malloc(size_t size); void *model_calloc(size_t count, size_t size); void * model_realloc(void *ptr, size_t size); void model_free(void *ptr); -/** @brief Provides a non-snapshotting allocator for use in STL classes. - * - * The code was adapted from a code example from the book The C++ - * Standard Library - A Tutorial and Reference by Nicolai M. Josuttis, - * Addison-Wesley, 1999 © Copyright Nicolai M. Josuttis 1999 - * Permission to copy, use, modify, sell and distribute this software - * is granted provided this copyright notice appears in all copies. - * This software is provided "as is" without express or implied - * warranty, and with no claim as to its suitability for any purpose. - */ -template -class ModelAlloc { -public: - // type definitions - typedef T value_type; - typedef T* pointer; - typedef const T* const_pointer; - typedef T& reference; - typedef const T& const_reference; - typedef size_t size_type; - typedef size_t difference_type; - - // rebind allocator to type U - template - struct rebind { - typedef ModelAlloc other; - }; - - // return address of values - pointer address(reference value) const { - return &value; - } - const_pointer address(const_reference value) const { - return &value; - } - - /* constructors and destructor - * - nothing to do because the allocator has no state - */ - ModelAlloc() throw() { - } - ModelAlloc(const ModelAlloc&) throw() { - } - template - ModelAlloc(const ModelAlloc&) throw() { - } - ~ModelAlloc() throw() { - } - - // return maximum number of elements that can be allocated - size_type max_size() const throw() { - return std::numeric_limits::max() / sizeof(T); - } - - // allocate but don't initialize num elements of type T - pointer allocate(size_type num, const void * = 0) { - pointer p = (pointer)model_malloc(num * sizeof(T)); - return p; - } - - // initialize elements of allocated storage p with value value - void construct(pointer p, const T& value) { - // initialize memory with placement new - new((void*)p)T(value); - } - - // destroy elements of initialized storage p - void destroy(pointer p) { - // destroy objects by calling their destructor - p->~T(); - } - - // deallocate storage p of deleted elements - void deallocate(pointer p, size_type num) { - model_free((void*)p); - } -}; - -/** Return that all specializations of this allocator are interchangeable. */ -template -bool operator ==(const ModelAlloc&, - const ModelAlloc&) throw() { - return true; -} - -/** Return that all specializations of this allocator are interchangeable. */ -template -bool operator!= (const ModelAlloc&, - const ModelAlloc&) throw() { - return false; -} - - #endif/* _MY_MEMORY_H */ diff --git a/src/order.c b/src/order.c index e69de29..727b2dd 100644 --- a/src/order.c +++ b/src/order.c @@ -0,0 +1 @@ +#include "order.h" diff --git a/src/order.h b/src/order.h index e40c879..b164a11 100644 --- a/src/order.h +++ b/src/order.h @@ -3,10 +3,6 @@ #include "classlist.h" #include "mymemory.h" -class Order { -public: - MEMALLOC; - -private: +struct Order { }; #endif diff --git a/src/predicate.h b/src/predicate.h index 3a79a9e..9a17669 100644 --- a/src/predicate.h +++ b/src/predicate.h @@ -3,10 +3,7 @@ #include "classlist.h" #include "mymemory.h" -class Predicate { -public: +struct Predicate { - MEMALLOC; -private: }; #endif diff --git a/src/set.c b/src/set.c index 043aece..c92de33 100644 --- a/src/set.c +++ b/src/set.c @@ -1,27 +1,28 @@ #include "set.h" #include -#include -Set::Set(VarType t, uint64_t* elements, int num) : - type (t), - isRange(false), - low(0), - high(0), - members(new ModelVector()) { - members->reserve(num); - for(int i=0;ipush_back(elements[i]); +Set * allocSet(VarType t, uint64_t* elements, uint num) { + Set * tmp=(Set *)ourmalloc(sizeof(struct Set)); + tmp->type=t; + tmp->isRange=false; + tmp->low=0; + tmp->high=0; + tmp->members=allocVectorArrayInt(elements, num); + return tmp; } -Set::Set(VarType t, uint64_t lowrange, uint64_t highrange) : - type(t), - isRange(true), - low(lowrange), - high(highrange), - members(NULL) { +Set * allocSetRange(VarType t, uint64_t lowrange, uint64_t highrange) { + Set * tmp=(Set *)ourmalloc(sizeof(struct Set)); + tmp->type=t; + tmp->isRange=true; + tmp->low=lowrange; + tmp->high=highrange; + tmp->members=NULL; + return tmp; } -Set::~Set() { - if (isRange) - delete members; +void freeSet(Set * set) { + if (set->isRange) + freeVectorInt(set->members); + ourfree(set); } diff --git a/src/set.h b/src/set.h index 8799208..dee4066 100644 --- a/src/set.h +++ b/src/set.h @@ -9,23 +9,19 @@ #define SET_H #include "classlist.h" -#include "stl-model.h" +#include "structs.h" #include "mymemory.h" -class Set { -public: - Set(VarType t, uint64_t * elements, int num); - Set(VarType t, uint64_t lowrange, uint64_t highrange); - ~Set(); - - MEMALLOC; -private: +struct Set { VarType type; bool isRange; uint64_t low, high; - -protected: - ModelVector *members; + VectorInt * members; }; + + +Set *allocSet(VarType t, uint64_t * elements, uint num); +Set * allocSetRange(VarType t, uint64_t lowrange, uint64_t highrange); +void freeSet(Set *set); #endif/* SET_H */ diff --git a/src/stl-model.h b/src/stl-model.h deleted file mode 100644 index d3fd8c3..0000000 --- a/src/stl-model.h +++ /dev/null @@ -1,51 +0,0 @@ -/* Copyright (c) 2015 Regents of the University of California - * - * Author: Brian Demsky - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * version 2 as published by the Free Software Foundation. - */ - -#ifndef __STL_MODEL_H__ -#define __STL_MODEL_H__ - -#include -#include -#include "mymemory.h" - -template -class ModelList : public std::list<_Tp, ModelAlloc<_Tp> > -{ -public: - typedef std::list< _Tp, ModelAlloc<_Tp> > list; - - ModelList() : - list() - { } - - ModelList(size_t n, const _Tp& val = _Tp()) : - list(n, val) - { } - - MEMALLOC; -}; - -template -class ModelVector : public std::vector<_Tp, ModelAlloc<_Tp> > -{ -public: - typedef std::vector< _Tp, ModelAlloc<_Tp> > vector; - - ModelVector() : - vector() - { } - - ModelVector(size_t n, const _Tp& val = _Tp()) : - vector(n, val) - { } - - MEMALLOC; -}; - -#endif/* __STL_MODEL_H__ */ diff --git a/src/structs.c b/src/structs.c new file mode 100644 index 0000000..7eea923 --- /dev/null +++ b/src/structs.c @@ -0,0 +1,5 @@ +#include "structs.h" +#include "mymemory.h" + +VectorImpl(Int, uint64_t, 4); +VectorImpl(Boolean, Boolean *, 4); diff --git a/src/structs.h b/src/structs.h new file mode 100644 index 0000000..4229f71 --- /dev/null +++ b/src/structs.h @@ -0,0 +1,8 @@ +#ifndef STRUCTS_H +#define STRUCTS_H +#include "vector.h" +#include "classlist.h" + +VectorDef(Int, uint64_t, 4); +VectorDef(Boolean, Boolean *, 4); +#endif diff --git a/src/table.h b/src/table.h index f726c4e..6e886b7 100644 --- a/src/table.h +++ b/src/table.h @@ -3,9 +3,9 @@ #include "classlist.h" #include "mymemory.h" -class Table { -public: - MEMALLOC; -private: +struct Table { + }; + +Table * allocTable(); #endif diff --git a/src/vector.h b/src/vector.h new file mode 100644 index 0000000..e9a3361 --- /dev/null +++ b/src/vector.h @@ -0,0 +1,57 @@ +#ifndef VECTOR_H +#define VECTOR_H +#include + +#define VectorDef(name, type, defcap) \ + struct Vector ## name { \ + uint size; \ + uint capacity; \ + type * array; \ + }; \ + typedef struct Vector ## name Vector ## name; \ + Vector ## name * allocVector ## name(uint capacity); \ + Vector ## name * allocDefVector ## name(); \ + Vector ## name * allocVectorArray ## name(type * array, uint capacity); \ + void pushVector ## name(Vector ## name *vector, type item); \ + type getVector ## name(Vector ## name *vector, uint index); \ + void setVector ## name(Vector ## name *vector, uint index, type item); \ + uint getSize ##name(Vector ##name *vector); \ + void freeVector ##name(Vector ##name *vector); + +#define VectorImpl(name, type, defcap) \ + Vector ## name * allocDefVector ## name() { \ + return allocVector ## name(defcap); \ + } \ + Vector ## name * allocVector ## name(uint capacity) { \ + Vector ## name * tmp = (Vector ## name *) ourmalloc(sizeof(type)); \ + tmp->size = 0; \ + tmp->capacity = capacity; \ + tmp->array = (type *) ourcalloc(1, sizeof(type) * capacity); \ + return tmp; \ + } \ + Vector ## name * allocVectorArray ## name(uint capacity, type * array) { \ + Vector ## name * tmp = allocVector ## name(capacity); \ + memcpy(tmp->array, array, capacity * sizeof(type)); \ + return tmp; \ + } \ + void pushVector ## name(Vector ## name *vector, type item) { \ + if (vector->size >= vector->capacity) { \ + uint newcap=vector->capacity * 2; \ + vector->array=(type *)ourrealloc(vector->array, newcap); \ + } \ + vector->array[vector->size++] = item; \ + } \ + type getVector ## name(Vector ## name * vector, uint index) { \ + return vector->array[index]; \ + } \ + void setVector ## name(Vector ## name * vector, uint index, type item) { \ + vector->array[index]=item; \ + } \ + uint getSize ## name(Vector ## name *vector) { \ + return vector->size; \ + } \ + void freeVector ##name(Vector ##name *vector) { \ + ourfree(vector->array); \ + ourfree(vector); \ + } +#endif -- 2.34.1