/usr/include/lite_score.h is in libsilo-dev 4.10.2-6+b3.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 | /*
Copyright (c) 1994 - 2010, Lawrence Livermore National Security, LLC.
LLNL-CODE-425250.
All rights reserved.
This file is part of Silo. For details, see silo.llnl.gov.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the disclaimer below.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the disclaimer (as noted
below) in the documentation and/or other materials provided with
the distribution.
* Neither the name of the LLNS/LLNL nor the names of its
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL LAWRENCE
LIVERMORE NATIONAL SECURITY, LLC, THE U.S. DEPARTMENT OF ENERGY OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
This work was produced at Lawrence Livermore National Laboratory under
Contract No. DE-AC52-07NA27344 with the DOE.
Neither the United States Government nor Lawrence Livermore National
Security, LLC nor any of their employees, makes any warranty, express
or implied, or assumes any liability or responsibility for the
accuracy, completeness, or usefulness of any information, apparatus,
product, or process disclosed, or represents that its use would not
infringe privately-owned rights.
Any reference herein to any specific commercial products, process, or
services by trade name, trademark, manufacturer or otherwise does not
necessarily constitute or imply its endorsement, recommendation, or
favoring by the United States Government or Lawrence Livermore
National Security, LLC. The views and opinions of authors expressed
herein do not necessarily state or reflect those of the United States
Government or Lawrence Livermore National Security, LLC, and shall not
be used for advertising or product endorsement purposes.
*/
/*
* SCORE.H - include file for PACT standard core package
*
* Source Version: 2.0
* Software Release #92-0043
*
*/
#ifdef PCK_SCORE
#error CANNOT INCLUDE SCORE PROPER AND SCORE LITE HEADERS IN SAME COMPILATION MODULE
#endif
#ifndef _LITE_SCORE_H
#define _LITE_SCORE_H
/*
* Standard include files...
*/
#include <limits.h> /*needed for SHRT_MAX*/
#include <stdio.h>
#if HAVE_STDLIB_H
# include <stdlib.h>
#endif
#if HAVE_STRING_H
# include <string.h>
#endif
#if HAVE_SYS_TYPES_H
# include <sys/types.h>
#endif
/*
* LITE exports for WIN32
*/
#ifndef LITE_API
#ifdef _WIN32
#ifdef LITE_STATIC_LIBRARY
#define LITE_API
#else
#ifdef LITE_EXPORTS
#define LITE_API __declspec(dllexport)
#else
#define LITE_API __declspec(dllimport)
#endif
#endif
#else
#define LITE_API
#endif
#endif
#ifdef __cplusplus
extern "C" {
#endif
#define SC_c_sp_alloc lite_SC_c_sp_alloc
#define SC_c_sp_free lite_SC_c_sp_free
#define SC_c_sp_diff lite_SC_c_sp_diff
#define SC_c_sp_max lite_SC_c_sp_max
#define LAST lite_LAST
#define SC_CHAR_S lite_SC_CHAR_S
#define SC_alloc lite_SC_alloc
#define SC_arrlen lite_SC_arrlen
#define SC_date lite_SC_date
#define SC_def_lookup lite_SC_def_lookup
#define SC_dump_hash lite_SC_dump_hash
#define SC_firsttok lite_SC_firsttok
#define SC_free lite_SC_free
#define SC_hash lite_SC_hash
#define SC_hash_clr lite_SC_hash_clr
#define SC_hash_dump lite_SC_hash_dump
#define SC_hash_rem lite_SC_hash_rem
#define SC_install lite_SC_install
#define SC_lasttok lite_SC_lasttok
#define SC_lookup lite_SC_lookup
#define SC_make_hash_table lite_SC_make_hash_table
#define SC_mark lite_SC_mark
#define SC_realloc lite_SC_realloc
#define SC_ref_count lite_SC_ref_count
#define SC_regx_match lite_SC_regx_match
#define SC_rl_hash_table lite_SC_rl_hash_table
#define SC_stoi lite_SC_stoi
#define SC_stol lite_SC_stol
#define SC_string_sort lite_SC_string_sort
#define SC_strrev lite_SC_strrev
#define SC_strsavef lite_SC_strsavef
/* Macros used for exporting symbols on Win32 systems. */
#ifdef _WIN32
# ifndef HAVE_MEMMOVE
# define HAVE_MEMMOVE
# endif
#endif
/*--------------------------------------------------------------------------*/
/* DEFINED CONSTANTS */
/*--------------------------------------------------------------------------*/
#ifndef FALSE
# define FALSE 0
# define TRUE 1
#endif
#define ERR_FREE 2 /*error free ret flg for longjmp*/
#define ABORT 3 /*error return flag for longjmps*/
#define BINARY_MODE_R "rb"
#define BINARY_MODE_RPLUS "r+b"
#define BINARY_MODE_WPLUS "w+b"
#define LRG_TXT_BUFFER 4096
#define NODOC 0
/* Possible hash table sizes. Should be primes */
#define HSZSMALL 521
#define HSZMEDIUM 5231
#define HSZLARGE 52121
#define HSZXLARGE 521021
#define SC_BITS_BYTE 8
#define SC_CHAR_I 1
#define SC_SHORT_I 2
#define SC_INTEGER_I 3
#define SC_LONG_I 4
#define SC_FLOAT_I 5
#define SC_DOUBLE_I 6
#define SC_REAL_I 7
#define SC_STRING_I 8
#define SC_POINTER_I 9
#define SC_PCONS_P_I 10
#define SC_VOID_I 11
#define SC_SHORT_P_I 12
#define SC_INTEGER_P_I 13
#define SC_LONG_P_I 14
#define SC_FLOAT_P_I 15
#define SC_REAL_P_I 16
#define SC_DOUBLE_P_I 17
#define SC_PCONS_I 18
#define SC_STRUCT_I 19 /*is this pointer type? */
#define SC_UNKNOWN_I 20
#define SC_CHAR_8_I 21 /*for F77 users and interfacers */
#define SC_USER_I 22 /*first user defined index available */
#define UNCOLLECT SHRT_MAX
#define MAXLINE FILENAME_MAX
#undef PRINT
#define PRINT (*putln)
#undef CONVERT
#define CONVERT (*SC_convert_hook)
#undef SIZEOF
#define SIZEOF (*SC_sizeof_hook)
#define io_close (*lite_io_close_hook)
#define io_flush (*lite_io_flush_hook)
#define io_open (*lite_io_open_hook)
#define io_printf (*lite_io_printf_hook)
#define io_read (*lite_io_read_hook)
#define io_seek (*lite_io_seek_hook)
#define io_setvbuf (*lite_io_setvbuf_hook)
#define io_tell (*lite_io_tell_hook)
#define io_write (*lite_io_write_hook)
#undef MAKE
#undef MAKE_N
#undef REMAKE
#undef REMAKE_N
#undef SFREE
#undef SFREE_N
/*--------------------------------------------------------------------------*/
/* PROCEDURAL MACROS */
/*--------------------------------------------------------------------------*/
#ifndef MIN
# define MIN(X,Y) ((X)<(Y)?(X):(Y))
#endif
#ifndef MAX
# define MAX(X,Y) ((X)>(Y)?(X):(Y))
#endif
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
#define DEREF(x) (*(char **) (x))
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
/* FMAKE - memory allocation and bookkeeping macro */
#define FMAKE(x, name) ((x *) lite_SC_alloc(1L, (long) sizeof(x), name))
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
/* FMAKE_N - allocate a block of type x and return a pointer to it */
#define FMAKE_N(x, n, name) ((x *)lite_SC_alloc((long)n,(long)sizeof(x),name))
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
/* MAKE_N - allocate a block of type x and return a pointer to it */
#define MAKE_N(x, n) ((x *) lite_SC_alloc((long) n, (long) sizeof(x), NULL))
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
/* REMAKE_N - reallocate a block of type x and return a pointer to it */
#define REMAKE_N(p, x, n) \
(p = (x *) lite_SC_realloc((lite_SC_byte *) p, (long) (n), (long) sizeof(x)))
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
/* SFREE - release memory and do bookkeeping */
#define SFREE(x) \
{lite_SC_free(x); \
x = NULL;}
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
/* TYPEDEFS AND STRUCTS */
/*--------------------------------------------------------------------------*/
typedef void lite_SC_byte ;
typedef void (*FreeFuncType)(void *) ;
typedef void *((*MallocFuncType)(size_t));
typedef void *((*ReallocFuncType)(void *,size_t));
typedef void (*PFVoid)() ;
typedef int (*PFInt)() ;
typedef long (*PFLong)() ;
typedef double (*PFDouble)() ;
/*
* Pcons definition
* - useful for linked lists, association lists and whatnot
* - the type fields are for bookkeeping that may be crucial to
* - other packages
*/
typedef struct s_pcons {
char *car_type;
lite_SC_byte *car;
char *cdr_type;
lite_SC_byte *cdr;
} pcons;
/*
* Hashel definition
* - hashel have two members, the name and def
* - the name is a string on which the function hash operates
* - type is a string which names the type of object associated
* - with the name and type checking on the object can be used
* - to determine appropriate casts for accessing the object
* - def is a pointer to an object, usually a struct with
* - the necessary members for the specific application
*/
typedef struct s_hashel {
char *name;
char *type;
lite_SC_byte *def;
struct s_hashel *next; /* next entry in chain */
} hashel ;
/*
* Hash table type.
*/
typedef struct s_hashtab {
int size;
int nelements;
int docp;
hashel **table;
} HASHTAB ;
typedef union u_SC_address {
long diskaddr;
PFInt funcaddr;
char *memaddr;
} SC_address ;
typedef FILE * (*PFfopen)(char*,char*);
typedef long (*PFftell)(void*);
typedef size_t (*PFfread)(lite_SC_byte*,size_t,size_t,void*);
typedef size_t (*PFfwrite)(void*,size_t,size_t,void*);
typedef int (*PFsetvbuf)(void*,char*,int,size_t);
typedef int (*PFfclose)(void*);
typedef int (*PFfseek)(void*,long,int);
typedef int (*PFfprintf)(void*,char*,...);
typedef int (*PFungetc)(int,void*);
typedef int (*PFfflush)(void*);
/*--------------------------------------------------------------------------*/
/* VARIABLE DECLARATIONS */
/*--------------------------------------------------------------------------*/
LITE_API extern int lite_SC_c_sp_alloc;
LITE_API extern int lite_SC_c_sp_free;
LITE_API extern int lite_SC_c_sp_diff;
LITE_API extern int lite_SC_c_sp_max;
LITE_API extern int * lite_LAST;
LITE_API extern char * lite_SC_CHAR_S ;
/* IO hooks */
extern PFfclose lite_io_close_hook; /* NOT_LITE_API */
extern PFfflush lite_io_flush_hook; /* NOT_LITE_API */
extern PFfopen lite_io_open_hook; /* NOT_LITE_API */
extern PFfprintf lite_io_printf_hook; /* NOT_LITE_API */
extern PFfread lite_io_read_hook; /* NOT_LITE_API */
extern PFfseek lite_io_seek_hook; /* NOT_LITE_API */
extern PFsetvbuf lite_io_setvbuf_hook; /* NOT_LITE_API */
extern PFftell lite_io_tell_hook; /* NOT_LITE_API */
extern PFfwrite lite_io_write_hook; /* NOT_LITE_API */
/*--------------------------------------------------------------------------*/
/* FUNCTION DECLARATIONS */
/*--------------------------------------------------------------------------*/
LITE_API extern lite_SC_byte * lite_SC_alloc (long,long,char*);
LITE_API extern long lite_SC_arrlen (lite_SC_byte*);
LITE_API extern char * lite_SC_date (void);
LITE_API extern lite_SC_byte * lite_SC_def_lookup (char*,HASHTAB*);
LITE_API extern char ** lite_SC_dump_hash (HASHTAB*,char*,int);
LITE_API extern char * lite_SC_firsttok (char*,char*);
LITE_API extern int lite_SC_free (lite_SC_byte*);
LITE_API extern int lite_SC_hash (char*,int);
LITE_API extern void lite_SC_hash_clr (HASHTAB*);
LITE_API extern char ** lite_SC_hash_dump (HASHTAB*,char*);
LITE_API extern int lite_SC_hash_rem (char*,HASHTAB*);
LITE_API extern hashel *lite_SC_install (char*,lite_SC_byte*,char*,HASHTAB*);
LITE_API extern char * lite_SC_lasttok (char*,char*);
LITE_API extern hashel *lite_SC_lookup (char*,HASHTAB*);
LITE_API extern HASHTAB *lite_SC_make_hash_table (int,int);
LITE_API extern int lite_SC_mark (lite_SC_byte*,int);
LITE_API extern lite_SC_byte * lite_SC_realloc (lite_SC_byte*,long,long);
LITE_API extern int lite_SC_ref_count (lite_SC_byte*);
LITE_API extern int lite_SC_regx_match (char*,char*);
LITE_API extern void lite_SC_rl_hash_table (HASHTAB*);
LITE_API extern int lite_SC_stoi (char*);
LITE_API extern long lite_SC_stol (char*);
LITE_API extern void lite_SC_string_sort (char**,int);
LITE_API extern char * lite_SC_strrev (char*);
LITE_API extern char * lite_SC_strsavef (char*,char*);
extern hashel * _lite_SC_install (char*,lite_SC_byte*,char*,HASHTAB*);
extern char * _lite_SC_pr_tok (char*,char*);
extern long int _lite_SC_strtol (char*,char**,int);
#ifndef HAVE_MEMMOVE
LITE_API extern void * memmove (void*,const void*,size_t) ;
#endif
#ifdef __cplusplus
}
#endif
#endif /* !_SCORE_H */
|