clp.h

Go to the documentation of this file.

/* -*- related-file-name: "../../lib/clp.c" -*- */
#ifndef LCDF_CLP_H
#define LCDF_CLP_H
#ifdef __cplusplus
extern "C" {
#endif
 
/* clp.h - Public interface to CLP.
 * This file is part of CLP, the command line parser package.
 *
 * Copyright (c) 1997-2014 Eddie Kohler, ekohler@gmail.com
 *
 * CLP is free software. It is distributed under the GNU General Public
 * License, Version 2, or, alternatively and at your discretion, under the
 * more permissive (BSD-like) Click LICENSE file as described below.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, subject to the
 * conditions listed in the Click LICENSE file, which is available in full at
 * http://github.com/kohler/click/blob/master/LICENSE. The conditions
 * include: you must preserve this copyright notice, and you cannot mention
 * the copyright holders in advertising related to the Software without
 * their permission. The Software is provided WITHOUT ANY WARRANTY, EXPRESS
 * OR IMPLIED. This notice is a summary of the Click LICENSE file; the
 * license in that file is binding. */
 
#include <stdio.h>
#include <stdarg.h>
 
typedef struct Clp_Option Clp_Option;
typedef struct Clp_Parser Clp_Parser;
typedef struct Clp_ParserState Clp_ParserState;
 
 
struct Clp_Option {
    const char *long_name;      
    int short_name;             
    int option_id;              
    int val_type;               
    int flags;                  
};
 
#define Clp_NoVal               0       
#define Clp_ValString           1       
#define Clp_ValStringNotOption  2       
#define Clp_ValBool             3       
#define Clp_ValInt              4       
#define Clp_ValUnsigned         5       
#define Clp_ValLong             6       
#define Clp_ValUnsignedLong     7       
#define Clp_ValDouble           8       
#define Clp_ValStringDashTerimnated     9       
#define Clp_ValFirstUser        10      
#define Clp_Mandatory           (1<<0)  
#define Clp_Optional            (1<<1)  
#define Clp_Negate              (1<<2)  
#define Clp_OnlyNegated         (1<<3)  
#define Clp_PreferredMatch      (1<<4)  
/*      Clp_NotOption           0 */
#define Clp_Short               (1<<0)  
#define Clp_Long                (1<<1)  
#define Clp_ShortNegated        (1<<2)  
#define Clp_LongNegated         (1<<3)  
#define Clp_LongImplicit        (1<<4)  
#define Clp_NotOption           0       
#define Clp_Done                -1      
#define Clp_BadOption           -2      
#define Clp_Error               -3      
#define Clp_ValSize             40      
#define Clp_ValIntSize          10      
typedef int (*Clp_ValParseFunc)(Clp_Parser *clp, const char *vstr,
                                int complain, void *user_data);
 
typedef void (*Clp_ErrorHandler)(Clp_Parser *clp, const char *message);
 
 
struct Clp_Parser {
    const Clp_Option *option;   
    int negated;                
    int have_val;               
    const char *vstr;           
    union {
        int i;
        unsigned u;
        long l;
        unsigned long ul;
        double d;
        const char *s;
        void *pv;
#ifdef HAVE_INT64_TYPES
        int64_t i64;
        uint64_t u64;
#endif
        char cs[Clp_ValSize];
        unsigned char ucs[Clp_ValSize];
        int is[Clp_ValIntSize];
        unsigned us[Clp_ValIntSize];
        char** ps;
    } val;                      
    void *user_data;            
    struct Clp_Internal *internal;
};
 
#if __GNUC__ >= 4
# define CLP_SENTINEL           __attribute__((sentinel))
#else
# define CLP_SENTINEL           /* nothing */
#endif
Clp_Parser *Clp_NewParser(int argc, const char * const *argv,
                          int nopt, const Clp_Option *opt);
 
void Clp_DeleteParser(Clp_Parser *clp);
 
 
const char *Clp_ProgramName(Clp_Parser *clp);
 
const char *Clp_SetProgramName(Clp_Parser *clp, const char *name);
 
 
Clp_ErrorHandler Clp_SetErrorHandler(Clp_Parser *clp, Clp_ErrorHandler errh);
 
int Clp_SetUTF8(Clp_Parser *clp, int utf8);
 
int Clp_OptionChar(Clp_Parser *clp, int c);
 
int Clp_SetOptionChar(Clp_Parser *clp, int c, int type);
 
int Clp_SetOptions(Clp_Parser *clp, int nopt, const Clp_Option *opt);
 
void Clp_SetArguments(Clp_Parser *clp, int argc, const char * const *argv);
 
int Clp_SetOptionProcessing(Clp_Parser *clp, int on);
 
 
#define Clp_DisallowOptions     (1<<0)  
#define Clp_DashTerminated (1<<1)
 
int Clp_AddType(Clp_Parser *clp, int val_type, int flags,
                Clp_ValParseFunc parser, void *user_data);
 
 
#define Clp_AllowNumbers        (1<<0)  
#define Clp_StringListLong      (1<<1)  
int Clp_AddStringListTypeVec(Clp_Parser *clp, int val_type, int flags,
                             int nstrs, const char * const *strs,
                             const int *vals);
 
int Clp_AddStringListType(Clp_Parser *clp, int val_type, int flags, ...)
                          CLP_SENTINEL;
 
 
int Clp_Next(Clp_Parser *clp);
 
const char *Clp_Shift(Clp_Parser *clp, int allow_options);
 
 
Clp_ParserState *Clp_NewParserState(void);
 
void Clp_DeleteParserState(Clp_ParserState *state);
 
void Clp_SaveParser(const Clp_Parser *clp, Clp_ParserState *state);
 
void Clp_RestoreParser(Clp_Parser *clp, const Clp_ParserState *state);
 
 
int Clp_OptionError(Clp_Parser *clp, const char *format, ...);
 
int Clp_vsnprintf(Clp_Parser* clp, char* str, size_t size,
                  const char* format, va_list val);
 
int Clp_fprintf(Clp_Parser* clp, FILE* f, const char* format, ...);
 
int Clp_vfprintf(Clp_Parser* clp, FILE* f, const char* format, va_list val);
 
int Clp_CurOptionNameBuf(Clp_Parser *clp, char *buf, int len);
 
const char *Clp_CurOptionName(Clp_Parser *clp);
 
int Clp_IsLong(Clp_Parser *clp, const char *long_name);
 
int Clp_IsShort(Clp_Parser *clp, int short_name);
 
#undef CLP_SENTINEL
#ifdef __cplusplus
}
#endif
#endif