[BACK]Return to rcs.h CVS log [TXT][DIR] Up to [local] / src / usr.bin / cvs

Annotation of src/usr.bin/cvs/rcs.h, Revision 1.5

1.5     ! jfb         1: /*     $OpenBSD: rcs.h,v 1.4 2004/12/16 17:16:18 jfb Exp $     */
1.1       jfb         2: /*
                      3:  * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
1.2       tedu        4:  * All rights reserved.
1.1       jfb         5:  *
1.2       tedu        6:  * Redistribution and use in source and binary forms, with or without
                      7:  * modification, are permitted provided that the following conditions
                      8:  * are met:
1.1       jfb         9:  *
1.2       tedu       10:  * 1. Redistributions of source code must retain the above copyright
                     11:  *    notice, this list of conditions and the following disclaimer.
1.1       jfb        12:  * 2. The name of the author may not be used to endorse or promote products
1.2       tedu       13:  *    derived from this software without specific prior written permission.
1.1       jfb        14:  *
                     15:  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
                     16:  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
                     17:  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
                     18:  * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
                     19:  * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
                     20:  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
                     21:  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
                     22:  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
                     23:  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
1.2       tedu       24:  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
1.1       jfb        25:  */
                     26:
                     27: #ifndef RCS_H
                     28: #define RCS_H
                     29:
                     30: #include <sys/types.h>
                     31: #include <sys/queue.h>
                     32:
                     33: #include <time.h>
                     34:
                     35: #include "buf.h"
                     36:
                     37: #define RCS_DIFF_MAXARG   32
                     38: #define RCS_DIFF_DIV \
                     39:        "==================================================================="
                     40:
                     41: #define RCS_FILE_EXT   ",v"
                     42:
                     43: #define RCS_HEAD_INIT  "1.1"
                     44:
                     45:
                     46: /* open modes */
                     47: #define RCS_MODE_READ   0x01
                     48: #define RCS_MODE_WRITE  0x02
                     49: #define RCS_MODE_RDWR   (RCS_MODE_READ|RCS_MODE_WRITE)
                     50:
                     51:
                     52: /* file flags */
                     53: #define RCS_RF_PARSED  0x01   /* file has been parsed */
                     54: #define RCS_RF_SYNCED  0x02   /* in-memory copy is in sync with disk copy */
                     55: #define RCS_RF_SLOCK   0x04   /* strict lock */
                     56:
                     57: /* delta flags */
                     58: #define RCS_RD_DEAD   0x01     /* dead */
1.5     ! jfb        59:
        !            60:
        !            61:
        !            62: #define RCSNUM_MAXNUM  USHRT_MAX
        !            63: #define RCSNUM_MAXLEN  64
1.1       jfb        64:
                     65:
                     66: typedef struct rcs_num {
                     67:        u_int      rn_len;
                     68:        u_int16_t *rn_id;
                     69: } RCSNUM;
                     70:
                     71:
                     72: struct rcs_sym {
                     73:        char    *rs_name;
                     74:        RCSNUM  *rs_num;
                     75:        TAILQ_ENTRY(rcs_sym) rs_list;
                     76: };
                     77:
                     78: struct rcs_lock {
                     79:        RCSNUM   *rl_num;
                     80:
                     81:        TAILQ_ENTRY(rcs_lock) rl_list;
                     82: };
                     83:
                     84:
                     85: struct rcs_branch {
                     86:        RCSNUM  *rb_num;
                     87:        TAILQ_ENTRY(rcs_branch) rb_list;
                     88: };
                     89:
                     90: struct rcs_dlist {
                     91:        struct rcs_delta *tqh_first;
                     92:        struct rcs_delta **tqh_last;
                     93: };
                     94:
                     95: struct rcs_delta {
                     96:        RCSNUM      *rd_num;
                     97:        RCSNUM      *rd_next;
                     98:        u_int        rd_flags;
                     99:        struct tm    rd_date;
                    100:        char        *rd_author;
                    101:        char        *rd_state;
                    102:        char        *rd_log;
                    103:        char        *rd_text;
                    104:
                    105:        struct rcs_dlist rd_snodes;
                    106:
                    107:        TAILQ_HEAD(, rcs_branch) rd_branches;
                    108:        TAILQ_ENTRY(rcs_delta)  rd_list;
                    109: };
                    110:
                    111:
                    112: typedef struct rcs_file {
                    113:        char   *rf_path;
                    114:        u_int   rf_ref;
                    115:        u_int   rf_mode;
                    116:        u_int   rf_flags;
                    117:
                    118:        RCSNUM *rf_head;
                    119:        RCSNUM *rf_branch;
                    120:        char   *rf_comment;
                    121:        char   *rf_expand;
                    122:        char   *rf_desc;
                    123:
                    124:        struct rcs_dlist rf_delta;
                    125:        TAILQ_HEAD(rcs_slist, rcs_sym)   rf_symbols;
                    126:        TAILQ_HEAD(rcs_llist, rcs_lock)  rf_locks;
                    127:
                    128:        void   *rf_pdata;
                    129: } RCSFILE;
                    130:
                    131:
                    132: RCSFILE*  rcs_open         (const char *, u_int);
                    133: void      rcs_close        (RCSFILE *);
                    134: int       rcs_parse        (RCSFILE *);
                    135: int       rcs_write        (RCSFILE *);
                    136: int       rcs_addsym       (RCSFILE *, const char *, RCSNUM *);
                    137: int       rcs_rmsym        (RCSFILE *, const char *);
                    138: BUF*      rcs_getrev       (RCSFILE *, RCSNUM *);
1.4       jfb       139: BUF*      rcs_gethead      (RCSFILE *);
1.1       jfb       140: RCSNUM*   rcs_getrevbydate (RCSFILE *, struct tm *);
                    141:
                    142: BUF*      rcs_patch     (const char *, const char *);
                    143: size_t    rcs_stresc    (int, const char *, char *, size_t *);
                    144:
                    145: RCSNUM*   rcsnum_alloc  (void);
                    146: void      rcsnum_free   (RCSNUM *);
                    147: int       rcsnum_aton   (const char *, char **, RCSNUM *);
                    148: char*     rcsnum_tostr  (const RCSNUM *, char *, size_t);
                    149: int       rcsnum_cpy    (const RCSNUM *, RCSNUM *, u_int);
                    150: int       rcsnum_cmp    (const RCSNUM *, const RCSNUM *, u_int);
                    151:
1.3       jfb       152: /* from cache.c */
                    153: int       rcs_cache_init    (u_int);
                    154: RCSFILE  *rcs_cache_fetch   (const char *path);
                    155: int       rcs_cache_store   (RCSFILE *);
                    156: void      rcs_cache_destroy (void);
1.1       jfb       157:
                    158: #endif /* RCS_H */