/usr/include/srecord/input/file.h is in libsrecord-dev 1.56-1build1.
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 | //
// srecord - manipulate eprom load files
// Copyright (C) 1998-2008, 2010 Peter Miller
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program. If not, see
// <http://www.gnu.org/licenses/>.
//
#ifndef SRECORD_INPUT_FILE_H
#define SRECORD_INPUT_FILE_H
#include <string>
#include <srecord/input.h>
namespace srecord {
/**
* The srecord::input_file class is used to represent an generic input
* file. It provides many helper methods common to most file input
* classes.
*/
class input_file:
public input
{
public:
/**
* The destructor.
*/
virtual ~input_file();
/**
* The guess class method is used to open a file of an unknown
* type. It attempts all of the know formats one after the other.
*
* @param file_name
* The name of the file to be opened.
*/
static pointer guess(const std::string &file_name);
/**
* The ignore_all_checksums method is used to set the global
* ignore checksums flag. This is usually the result of an
* --ignore-checksums command line option.
*/
static void ignore_all_checksums() { ignore_checksums_default = true; }
protected:
// See base class for documentation.
virtual std::string filename() const;
// See base class for documentation.
virtual std::string filename_and_line() const;
// See base class for documentation.
void disable_checksum_validation();
protected:
/**
* The constructor. The input will be taken from the named file
* (or the standard input if the filename is "-").
*
* Only derived classes may use this constructor.
*
* @param file_name
* The name of the file to be read.
*/
input_file(const std::string &file_name);
/**
* The get_char method is used to fetch a character from
* the input. Usually, this is sufficient, however derived
* classes may over-ride it if they have a special case.
* Over-ride with caution, as it affects many other methods.
*
* The line_number instance variable is maintained, so that the
* filename_and_line method may report the current file location.
* This makes for more informative error messages.
*/
virtual int get_char();
/**
* The get_char_undo method is used to return a character to
* the input. (a later get_char or peak_char method will see
* it again). Only one character may be pushed back.
*/
virtual void get_char_undo(int);
/**
* The peek_char method is used to look at the next character
* of input, without actually consuming it (a later get_char
* or peak_char method will still see it).
*/
int peek_char();
/**
* The get_nibble_value class method is used to translate a
* character into its hexadecimal value.
*
* @param c
* The character to translate
* @returns
* int; 0..9 for '0'..'9', 10..15 for 'a'..'f',
* 10..15 for 'A-Z', and -1 for everything else.
*/
static int get_nibble_value(int c);
/**
* The get_nibble method is used to fetch one hexadecimal digit
* from the input, via the get_char method. It is not case
* sensitive. It returns a value for 0 to 15. Characters which
* are not hexadecimal digits will result in a fatal error,
* and the method call will not return.
*/
int get_nibble();
/**
* The get_byte method is used to fetch a byte value from the
* input. The default implementation is to call the get_nibble
* method twice, and assemble them big-endian (most significant
* nibble first).
*
* The value of the byte will be added to the running checksum,
* via the checksum_add method.
*
* Usually, this get_byte method implementation is sufficient for
* most input classes, however derived classes may over-ride
* it if they have a special case. Over-ride with caution,
* as it affects many other methods.
*/
virtual int get_byte();
/**
* The get_word method is used to fetch a 16-bit value from the
* input. The get_byte method is called twice, and the two byte
* values are assembles big-endian (most significant byte first).
*/
int get_word();
/**
* The get_3bytes method is used to fetch a 24-bit value from
* the input. The get_byte method is called three times,
* and the three byte values are assembles big-endian (most
* significant byte first).
*/
unsigned long get_3bytes();
/**
* The get_4bytes method is used to fetch a 32-bit value from
* the input. The get_byte method is called four times,
* and the three byte values are assembles big-endian (most
* significant byte first).
*/
unsigned long get_4bytes();
/**
* The checksum_get method is used to get the current value of
* the running checksum (added to by the checksum_add method,
* usually called by the get_byte method). Only the lower 8
* bits of the sum are returned.
*/
int checksum_get() const;
/**
* The checksum_get16 method is used to get the current value of
* the running checksum (added to by the checksum_add method,
* usually called by the get_byte method). Only the lower 16
* bits of the sum are returned.
*/
int checksum_get16() const;
/**
* The checksum_add method is used to add another 8-bit value
* to the running checksum.
*/
virtual void checksum_add(unsigned char n);
/**
* The checksum_rest method is used to set the running checksum
* to zero.
*/
void checksum_reset();
/**
* The seek_to_end method is used to move the input position
* to the end of the file.
*/
void seek_to_end();
/**
* The mode method is used to return a suitable mode string for
* an fopen call. The default implementation is "r", assuming
* a text file. Other file formats may need to override this
* if they have other needs (e.g. "rb" for binary).
*/
virtual const char *mode() const;
private:
/**
* The file_name instance variable is used by the filename
* and filename_and_line methods to report the name of the
* input file. This makes for informative error messages.
*/
std::string file_name;
/**
* The line_number instance variable is used by the get_char
* method to remember the current line number. It us used by the
* filename_and_line method to report the current file location.
*/
int line_number;
/**
* The prev_was_newline instance variable is used by the
* get_char method to know when to increment the line number.
* It is not done when a newline is seen, but rather on reading
* the first character after a newline. In this way, the error
* messages refer to the correct line, when if (when) it was
* the the error message must be issued only when the whole
* line has bean read in, including the newline. error message.
*/
bool prev_was_newline;
/**
* The vfp instance variable is used by the get_fp method to
* remember the file pointer. You need to cast it to FILE* before
* you use it. Never access this instance variable directly,
* always go via the get_fp method. This ensures the file has
* been opened first!
*/
void *vfp;
protected:
/**
* The checksum instance variable is used record the running
* checksum. NEVER access this variable directly. Always use
* the checksum_reset() method to set it mack to its initial state.
* Always use the checksum_add method to add a byte to it.
* Always use the checksum_get() or checksum_get16() methods to
* read its value.
*/
int checksum;
/**
* The use_checksums method is used to determine whether or not to
* validate checksums when data is read.
*
* @returns
* bool; true if need to check checksums, false to ignore checksums.
*/
bool use_checksums() const { return !ignore_checksums; }
private:
/**
* The is_text instance variable is used remember if a file mode
* is text (true) or binary (false). This information is used
* by the get_char method to decide to increment the line number
* or not, and by the filename_and_line method to decide whether
* or not to include the line number in the location reported.
*
* This instance variable is set by the get_fp method when it
* opens the file.
*/
int is_text;
/**
* The ignore_checksums instance variable is used to remember
* whether or not checksums should be ignored (true) or validated
* (false).
*/
bool ignore_checksums;
/**
* The ignore_checksums_default class variable is used to remember
* the default checksum validation. Defaults to false.
*/
static bool ignore_checksums_default;
/**
* The get_fp method is used to get the stdio file pointer
* associated with this input file. (By avoiding a FILE*
* declaration, we avoid having to include <stdio.h> for no
* particularly good reason. Take care when casting.)
*
* If the file has not been opened yet, it will be opened by
* this method.
*/
void *get_fp();
/**
* The default constructor. Do not use.
*/
input_file();
/**
* The copy constructor. Do not use.
*/
input_file(const input_file &);
/**
* the assignment operator. Do not use.
*/
input_file &operator=(const input_file &);
};
};
#endif // SRECORD_INPUT_FILE_H
|