Mercurial > ~dholland > hg > ag > index.cgi
view oldclasslib/include/util.h @ 16:f9e4689b837d
Some minor updates for 15 years later.
author | David A. Holland |
---|---|
date | Tue, 31 May 2022 01:45:26 -0400 |
parents | 13d2b8934445 |
children |
line wrap: on
line source
/* * AnaGram, a System for Syntax Directed Programming * * Utility Class Definitions * For copying, clearing, protecting and duplicating arrays. * * These class definitions are complete within this file. * There is no corresponding CPP module. * * Copyright 1993 Parsifal Software. All Rights Reserved. * * This software is provided 'as-is', without any express or implied * warranty. In no event will the authors be held liable for any damages * arising from the use of this software. * * Permission is granted to anyone to use this software for any purpose, * including commercial applications, and to alter it and redistribute it * freely, subject to the following restrictions: * * 1. The origin of this software must not be misrepresented; you must not * claim that you wrote the original software. If you use this software * in a product, an acknowledgment in the product documentation would be * appreciated but is not required. * 2. Altered source versions must be plainly marked as such, and must not be * misrepresented as being the original software. * 3. This notice may not be removed or altered from any source distribution. */ #ifndef UTIL_H #define UTIL_H #include <string.h> // General purpose copy procedure. Works with pointers of any type. template<class T> void copy(T *dest, const T *src, unsigned n) { memmove(dest, src, n*sizeof(T)); } template<class T> void copy(T *dest, const T *src) { memmove(dest, src, sizeof(T)); } // Clear an array to zero template <class T> T *clear(T *dest, unsigned n) { memset(dest, 0, n*sizeof(T)); return dest; } template <class T> T *clear(T *dest) { memset(dest, 0, sizeof(T)); return dest; } // Make a duplicate of any array template <class T> T *memdup(const T *src, unsigned n) { T *result = new T[n]; memmove(result, src, n*sizeof(T)); return result; } // General purpose class for saving and restoring data arrays template <class T> class protect { private: T *save_value; unsigned n; T *original_pointer; public: protect(T *p, unsigned k) { save_value = new T[n = k]; copy(save_value, p, n); original_pointer = p; } protect(T *p) { save_value = new T[n = 1]; copy(save_value, p, n); original_pointer = p; } ~protect() { copy(original_pointer, save_value, n); delete [] save_value; } }; #endif