home *** CD-ROM | disk | FTP | other *** search
/ Almathera Ten Pack 3: CDPD 3 / Almathera Ten on Ten - Disc 3: CDPD3.iso / scope / 101-125 / scopedisk106 / bbs-index / src / bbsindex.h < prev    next >
Encoding:
C/C++ Source or Header  |  1995-03-19  |  17.0 KB  |  347 lines
  1. /*
  2.  *             BBSINDEX.H
  3.  *     
  4.  *             All the standard variables and other stuff used by all the modules
  5.  *             of BBSindex, and standard BBS-PC! headers (with a few modifications).
  6.  *
  7.  *             Important note: This header file cannot be precompiled with
  8.  *             Lattice C V5.02, because of a bug which prevents bit fields
  9.  *             from working properly when they are precompiled.
  10.  */
  11.  
  12. #include "bbs.h"
  13.  
  14. #define TRUE   1
  15. #define FALSE  0
  16.  
  17. #define BTOK(x) (((x)+1023)>>10)       /* Convert file size into K */
  18.  
  19. /*
  20.  *             Default values for command line parameters and script commands
  21.  */
  22.  
  23. #define FORMAT         "%15n %w %-6x-%b{B,T}  %c\n"
  24. #define UDNAME         "UDHEAD.DAT"
  25. #define CFGNAME                "CFGINFO.DAT"
  26. #define PROGSCRIPT     "BBSCRIPT"
  27. #define DEFSCRIPT      "BBSindex.scr"
  28.  
  29. /*
  30.  *     Blocksize determines the largest contiguous memory segment which is
  31.  *     needed. Larger values give faster processing, but need more continuous
  32.  *     memory.
  33.  */
  34.  
  35. #define        BLOCKSIZE       160                             /* Number of records/block (~16K)               */
  36. #define MAXOUT         1024                    /* The maximum length of an output line */
  37. #define        MAXCOM          1024                    /* Maximum size of a single command             */
  38. #define MAXSUB         256                             /* Maximum size of a sub format string  */
  39. #define FRAGBLOCK      8192                    /* Memory block to allocate in mymalloc */
  40. #define FRAGTHRESH     200                             /* Threshold for mem reqs in mymalloc   */
  41. #define BUFSIZE                8192                    /* Maximum size of output buffer                */
  42. #define MAXEXPR                100                             /* Max number of items in an expression */
  43. #define MAXDIRENT      1000                    /* Maximum number of unknown dir files  */
  44. #define DIRFRAG                100                             /* Number of dir entries/block alloced  */
  45. #define DIRNAMESIZE    80                              /* Maximum length of directory name             */
  46. #define MACROLEN       20                              /* Maximum length of macro name                 */
  47. #define MAXMACRO       50                              /* Maximum number of macros allowed             */
  48. #define MAXNEST                10                              /* Max number of macro nesting levels   */
  49. #define MAXCONST       20                              /* Maximum length of a constant name    */
  50.  
  51. /* Note: MAXSUB above is allocated on the stack, so don't make it too big */
  52.  
  53. /*
  54.  *             This structure is used to build a tree structure representing
  55.  *             the expression given with the SELECT command.
  56.  */
  57. struct expr {
  58.        int             field;                  /* Field to test, or boolean operator   */
  59.        int             op;                             /* Operator to test against, if any             */
  60.        int             num;                    /* First data field                                             */
  61.        char    *text;                  /* Second data field                                    */
  62.        struct  expr *left;             /* Left subtree                                                 */
  63.        struct  expr *right;    /* Right subtree                                                */
  64. };
  65.  
  66. typedef struct expr EXPR;
  67.  
  68. /*
  69.  *             This structure is used to hold the name of a file found in
  70.  *             a BBS-PC! file directory during CHECKFILES, which does not
  71.  *             exist in the BBS-PC! file catalogue.
  72.  */
  73. typedef struct {
  74.        char    name[32];               /* Disk filename                                                */
  75.        short   date;                   /* In BBS-PC! format, max 16 bits               */
  76.        short   dirnum;                 /* The directory number it was in               */
  77.        long    size;                   /* The size of the file, in bytes               */
  78. } DIRENTRY;
  79.  
  80. #define DIRENTRYSIZE   sizeof(DIRENTRY)
  81.  
  82. /*
  83.  *             This structure holds the names of files to be "ignored" during a
  84.  *             CHECKFILES. I.e. they are marked as valid, even if their filesize
  85.  *             on disk doesn't match that in the file catalogue. This structure
  86.  *             is built up with the IGNORE command.
  87.  */
  88. struct ignore {
  89.        struct ignore *next;
  90.        char name[CAT_LEN+1];
  91. };
  92.  
  93. typedef struct ignore IGNORE;
  94.  
  95. /*
  96.  *             This structure is used to store macro definitions. Note that
  97.  *             a single block is used to store both the macro and its definition.
  98.  *             The structure is dynamically sized at runtime, to fit whatever
  99.  *             size definition is given. The text[] array (nominally 1) gets
  100.  *             expanded to hold the definition.
  101.  */
  102. typedef struct {
  103.        char    name[MACROLEN]; /* Name of this macro                                   */
  104.        int             size;                   /* Size of macro text                                   */
  105.        char    text[1];                /* Start of macro text                                  */
  106. } MACRO;
  107.  
  108. #define MACROSIZE              (sizeof(MACRO) - 1)             /* The -1 is for text[1] */
  109.  
  110. /*
  111.  *             This structure holds a block of parameters for a macro that is
  112.  *             executing.
  113.  */
  114. typedef struct {
  115.        int             size;                   /* Size of parameter block                              */
  116.        char    params[1];              /* Start of parameter block                             */
  117. } PARAM;
  118.  
  119. #define PARAMSIZE              (sizeof(PARAM) - 1)             /* The -1 is for params[1] */
  120.  
  121.  
  122. /*
  123.  *             This macro checks to make sure that the file database has been
  124.  *             read in. This is delayed until as late as possible, so that if
  125.  *             the script file contains errors, the errors will be spotted BEFORE
  126.  *             the database is read in. The primary goal here is to save the user
  127.  *             having to wait for 200K or so of database to be read in, just so
  128.  *             they can see they have an error in their script. Instead, the
  129.  *             database is only read in when a command cannot execute without
  130.  *             having access to the files. Such commands are SORT, SCAN, LIST,
  131.  *             CHECKFILES and FOREIGN.
  132.  */
  133. #define CHECKDATABASE() {if (!readfiles) readdatabase(databasename);}
  134.  
  135. /*
  136.  *             Global variables, accessible to all modules
  137.  */
  138.  
  139. #ifdef GLOBAL
  140. #undef GLOBAL
  141. #endif
  142. #ifdef MAIN
  143. #define GLOBAL
  144. #else
  145. #define GLOBAL extern
  146. #endif
  147.  
  148. GLOBAL char *script;                   /* Array for storing the script                         */
  149. GLOBAL long scriptsize;                        /* The size of the current script                       */
  150. GLOBAL long scriptpos;                 /* Position in the current script                       */
  151. GLOBAL long linenum;                   /* Line number in script file                           */
  152. GLOBAL char out[MAXOUT];               /* Array for storing the output lines           */
  153. GLOBAL char combuf[MAXCOM];            /* Buffer to hold a single command                      */
  154. GLOBAL char formatstring[MAXCOM];/* Used to store the output format string     */
  155. GLOBAL char databasename[256]; /* The name of the BBS-PC! file database        */
  156. GLOBAL char configname[256];   /* The name of the BBS-PC! config file          */
  157. GLOBAL char scriptname[256];   /* The name of the current script file          */
  158. GLOBAL UDHEAD **ptrblock;              /* Array of pointers to file records            */
  159. GLOBAL long numrecs;                   /* The number of file headers read in           */
  160. GLOBAL long compos;                            /* Position on the current command line         */
  161. GLOBAL long comlen;                            /* Length of current command line                       */
  162. GLOBAL BPTR outfile;                   /* Output file (Default is stdout)                      */
  163. GLOBAL BPTR errorfile;                 /* Standard error file (screen usually)         */
  164. GLOBAL BPTR dirlock;                   /* Lock used when scanning directories          */
  165. GLOBAL struct FileInfoBlock *fib;/* Global fib struct on longword boundary     */
  166. GLOBAL int checkfiles;                 /* TRUE if file directories were scanned        */
  167. GLOBAL int readfiles;                  /* TRUE if database file has been read in       */
  168. GLOBAL int toscreen;                   /* TRUE if output is to screen                          */
  169. GLOBAL int totalbytes;                 /* Total number of bytes output so far          */
  170. GLOBAL int totalfiles;                 /* Total number of files output so far          */
  171. GLOBAL int curbytes;                   /* Number of bytes output by last LIST/SCAN     */
  172. GLOBAL int curfiles;                   /* Number of files output by last LIST/SCAN     */
  173. GLOBAL int sorted;                             /* True if file array has been sorted           */
  174. GLOBAL EXPR tree[MAXEXPR];             /* Array to hold parsed SELECT expression       */
  175. GLOBAL int numdirentries;              /* Number of fake directory entries                     */
  176. GLOBAL DIRENTRY *direntries[MAXDIRENT];/* Storage for ptrs to dir entries      */
  177. GLOBAL char dirnames[NUM_SECT][DIRNAMESIZE];/* Storage for directory names     */
  178. GLOBAL CFGINFO config[1];              /* BBS-PC! Configuration file structure         */
  179. GLOBAL MACRO *macros[MAXMACRO];        /* Array of ptrs to macro definitions           */
  180. GLOBAL int nummacros;                  /* Number of macros currently defined           */
  181. GLOBAL PARAM *params[MAXNEST]; /* Array of pointers to macro parameters        */
  182. GLOBAL int nestlevel;                  /* Current macro nest level                                     */
  183. GLOBAL int tracemode;                  /* Trace mode; TRUE if tracing enabled          */
  184. GLOBAL IGNORE *firstignore;            /* Pointer to first filename to ignore          */
  185.  
  186. /*
  187.  *             Global functions, accessible everywhere
  188.  */
  189.  
  190. char *format();                /* Format output string from file header + format spec  */
  191. char *echoformat();    /* Formats output string for ECHO command                               */
  192. char *itoa();          /* Convert integer into ASCII format                                    */
  193. char *getstring();     /* Get next string from command buffer                                  */
  194. void *mymalloc();      /* Safe memory tracker that handles out of memory               */
  195. void *SafeAllocMem();/* Safe AllocMem that handles out of memory                       */
  196. void execscript();     /* Executes all the commands in the current script              */
  197. void Cleanup();                /* Frees resources and exits program                                    */
  198. void chkabort();       /* Checks for Control-C, and aborts if detected                 */
  199. void putstring();      /* Outputs string to standard I/O                                               */
  200. void flushout();       /* Flushes data buffer to output file                                   */
  201. void parse();          /* Parse command line and build expression tree                 */
  202. void readdatabase();/* Reads in the BBS-PC! UDHEAD.DAT file database           */
  203. void readconfigfile();/* Reads in the BBS-PC! CFGINFO.DAT file                         */
  204. void print();          /* Prints a string to stderr                                                    */
  205. void com_select();     /* SELECT, specifies criteria for files to select               */
  206. void com_checkfiles();/* Scans file directories, updating catlague entries     */
  207. void com_sort();       /* Sorts file catalogue into a particular order                 */
  208. void com_foreign();    /* Prints a list of all the unknown foreign files               */
  209. void com_norequest();/* Stop AmigaDos from putting up requesters                       */
  210. int match();           /* Returns TRUE if record matches current selection             */
  211. int scandir();         /* Scans directory for files, returns TRUE if continue  */
  212. int sortcmp();         /* Internal routine used for sorting files                              */
  213.  
  214. /*
  215.  *             print3()
  216.  *             --------
  217.  *             Prints 3 strings to standard error
  218.  */
  219. #define print2(s1,s2)   (print(s1), print(s2))
  220. #define print3(s1,s2,s3) (print(s1), print(s2), print(s3))
  221.  
  222. /*
  223.  *             The list of identifiers used by SORT and SELECT.
  224.  */
  225.  
  226. #define MAXINDEX 16
  227.  
  228. #define I_ANY                  0
  229. #define I_ACCESS               1
  230. #define I_BINARY               2
  231. #define I_COMMENT              3
  232. #define I_DISKNAME             4
  233. #define I_SECTION              5
  234. #define I_ONLINE               6
  235. #define I_LOCAL                        7
  236. #define I_NAME                 8
  237. #define I_OWNER                        9
  238. #define I_PATHNAME             10
  239. #define I_DIRECTORY            11
  240. #define I_DISKDIRNUM   12
  241. #define I_VALID                        13
  242. #define I_DATE                 14
  243. #define I_SIZE                 15
  244. #define I_KSIZE                        16
  245.  
  246. GLOBAL struct {
  247.        int tag;
  248.        char *name;
  249. } indexes[MAXINDEX]
  250. #ifdef MAIN
  251. = {
  252.  
  253. {      I_ACCESS,               "ACCESS"},              /* Number of times file was accessed    */
  254. {      I_BINARY,               "BINARY"},              /* True if Binary, False if text                */
  255. {      I_COMMENT,              "COMMENT"},             /* The file comment                                             */
  256. {      I_DISKNAME,             "DISKNAME"},    /* The name of the file on disk                 */
  257. {      I_SECTION,              "SECTION"},             /* # of the section the file is in              */
  258. {      I_ONLINE,               "ONLINE"},              /* True if file online                                  */
  259. {      I_LOCAL,                "LOCAL"},               /* True if file uploaded locally                */
  260. {      I_NAME,                 "NAME"},                /* The name of the file in the catalog  */
  261. {      I_OWNER,                "OWNER"},               /* The name of uploader of the file             */
  262. {      I_PATHNAME,             "PATHNAME"},    /* Pathname to file on disk                             */
  263. {      I_DIRECTORY,    "DIRECTORY"},   /* # of directory file is in                    */
  264. {      I_DISKDIRNUM,   "DISKDIRNUM"},  /* # of disk directory file is in               */
  265. {      I_VALID,                "VALID"},               /* True if file is Valid                                */
  266. {      I_DATE,                 "DATE"},                /* The date the file was uploaded               */
  267. {      I_SIZE,                 "SIZE"},                /* The size of the file                                 */
  268. {      I_KSIZE,                "KSIZE"}                /* The size of the file in K                    */
  269. }
  270. #endif
  271. ;
  272.  
  273. GLOBAL char *months[]
  274. #ifdef MAIN
  275. = {
  276.        "xxx",
  277.        "Jan", "Feb", "Mar", "Apr", "May", "Jun",
  278.        "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
  279. }
  280. #endif
  281. ;
  282.  
  283. /*
  284.  *             Special characters that can occur in the script
  285.  */
  286. #define CHAR_TAB               '\t'
  287. #define CHAR_SPACE             ' '
  288. #define CHAR_HASH              '#'
  289. #define CHAR_NL                        '\n'
  290. #define CHAR_ESC               '\\'
  291. #define CHAR_QUOTE             '\''
  292. #define CHAR_QUOTES            '\"'
  293. #define CHAR_SEMI              ';'
  294. #define CHAR_COMMA             ','
  295. #define CHAR_EQUALS            '='
  296. #define CHAR_DOLLAR            '$'
  297. #define CHAR_NULL              '\0'
  298.  
  299. #define CHAR_ASCEND            '+'
  300. #define CHAR_DESCEND   '-'
  301.  
  302. /*
  303.  *             The following symbols are used in the expression tree
  304.  */
  305.  
  306. /*
  307.  *             Boolean operations, which share storage with field selectors
  308.  */
  309.  
  310. #define E_AND          30      /* <left> AND <right>   */
  311. #define        E_OR            31      /* <left> OR <right>    */
  312. #define        E_NOT           32      /* NOT <left>                   */
  313. #define E_ALL          33      /* Always true                  */
  314.  
  315. /*
  316.  *             Comparison operators, used for comparing record elements
  317.  */
  318. #define        E_EQ            34      /* Record == Value              */
  319. #define E_NE           35      /* Record != Value              */
  320. #define E_LT           36      /* Record <  Value              */
  321. #define E_GT           37      /* Record >  Value              */
  322. #define E_LE           38      /* Record <= Value              */
  323. #define E_GE           39      /* Record >= Value              */
  324.  
  325. #define E_OPENPAR      40      /* Open parameter token         */
  326. #define E_CLOSEPAR     41      /* Close parameter token        */
  327.  
  328. #define E_NUMBER       42      /* Any numeric value            */
  329. #define E_STRING       43      /* Anything in quotes           */
  330. #define E_END          44      /* End of command line          */
  331.  
  332. #define E_TEXT         45      /* File is a text file          */
  333. #define E_REMOTE       46      /* File is a remote file        */
  334. #define E_INVALID      47      /* File is invalid                      */
  335. #define E_OFFLINE      48      /* File is offline                      */
  336.  
  337.  
  338. /*
  339.  *             Wildcard special fields for strings
  340.  */
  341. #define tokentowild(x) ((x)+50)
  342.  
  343. #define W_OWNER                tokentowild(I_OWNER)
  344. #define W_NAME         tokentowild(I_NAME)
  345. #define W_DISKNAME     tokentowild(I_DISKNAME)
  346. #define W_COMMENT      tokentowild(I_COMMENT)
  347.