Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

823 lines
22 KiB

//
// hdivide.cpp -- yet another header file divider
//
// 1998 Nov Hiro Yamamoto
//
#pragma warning(disable: 4786)
#include <cstdio>
#include <string>
#include <cstdarg>
#include <map>
#include <vector>
#include <cassert>
#include <io.h>
#define PROGNAME "hdivide"
#define VERSION "1.0"
extern "C" {
extern int getopt(int argc, char** argv, const char* opts);
extern int optind;
}
namespace opt {
bool verbose;
}
namespace input {
unsigned long length;
int lineno = 1;
std::string path;
std::string strip(const std::string& fname)
{
std::string stripped;
//
// find the "path" part
//
int n = fname.rfind('\\');
if (n < 0) {
n = fname.rfind('/');
}
if (n < 0 && (n = fname.rfind(':')) < 0) {
n = 0;
}
else {
++n;
}
// store the path
path = fname.substr(0, n);
// retrive the filename portion
stripped = fname.substr(n, fname.length());
return stripped;
}
}
#ifndef ARRAY_SIZE
#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
#endif
namespace id {
const char all[] = "all";
const char begin[] = "begin";
const char end[] = "end";
const char else_[] = "else";
const int begin_size = ARRAY_SIZE(begin) - 1;
const int end_size = ARRAY_SIZE(end) - 1;
const int else_size = ARRAY_SIZE(else_) - 1;
const char internal[] = "internal";
const char public_[] = "public";
const char null[] = "null";
std::string privatefile;
std::string publicfile;
const char insert[] = "insert";
const int insert_size = ARRAY_SIZE(insert) - 1;
const char reference_start[] = "reference_start";
const char reference_end[] = "reference_end";
}
#define MYFAILURE_OPENFILE (120)
#define MYFAILURE_INVALID_FORMAT (121)
using namespace std;
//////////////////////////////////////////////////////////////////////////
// usage
//////////////////////////////////////////////////////////////////////////
void usage()
{
fputs(PROGNAME ": version " VERSION "\n", stderr);
fputs("usage: hdivide [-v] input-filename (no path name please)\n", stderr);
}
//////////////////////////////////////////////////////////////////////////
// misc. helpers
//////////////////////////////////////////////////////////////////////////
inline void makeupper(string& str)
{
for (int i = 0; i < str.length(); ++i) {
str[i] = (char)toupper(str[i]);
}
}
inline void makelower(string& str)
{
for (int i = 0; i < str.length(); ++i) {
str[i] = (char)tolower(str[i]);
}
}
namespace msg {
void __cdecl error(const char* fmt, ...)
{
va_list args;
fputs(PROGNAME ": [error] ", stderr);
va_start(args, fmt);
vfprintf(stderr, fmt, args);
va_end(args);
putc('\n', stderr);
}
void __cdecl verbose(const char* fmt, ...)
{
if (!opt::verbose)
return;
va_list args;
fputs(PROGNAME ": ", stderr);
va_start(args, fmt);
vfprintf(stderr, fmt, args);
va_end(args);
putc('\n', stderr);
}
}
//////////////////////////////////////////////////////////////////////////
// class Output
//////////////////////////////////////////////////////////////////////////
class Output;
class Insertion {
public:
// somehow the default constructor is required for std::vector
// on NT5 build environment, as of Nov 1998
explicit Insertion() : m_insert(NULL), m_insertion_point(-1) { }
explicit Insertion(Output* insert, int point)
: m_insert(insert), m_insertion_point(point)
{
}
public:
Output* m_insert;
int m_insertion_point;
};
class Reference {
public:
// somehow the default constructor is required for std::vector
// on NT5 build environment, as of Nov 1998
Reference() : m_start(-1), m_end(-1) { }
explicit Reference(int start, int end)
: m_start(start), m_end(end) { }
public:
int m_start;
int m_end;
};
class Output {
public:
explicit Output(const string& name)
: m_name(name),
m_fname(input::path + name + ".x"),
m_alive(true),
m_insertion_finished(false),
m_reference_start(-1)
{
msg::verbose("opening %s", m_fname.c_str());
if ((m_fp = fopen(m_fname.c_str(), "wt")) == NULL) {
msg::error("cannot open file %s", m_fname.c_str());
throw MYFAILURE_OPENFILE;
}
if (m_tomem) {
m_buffer.reserve(input::length);
}
}
virtual ~Output();
public:
void setalive(bool alive)
{
m_alive = alive;
}
bool getalive()
{
return m_alive;
}
const string& getname()
{
return m_name;
}
void put(int c)
{
assert(m_fp);
if (m_alive) {
if (m_tomem) {
m_buffer += (char)c;
}
else {
putc(c, m_fp);
}
}
}
void puts(const char* s)
{
assert(m_fp);
if (m_alive) {
if (m_tomem) {
m_buffer += s;
}
else {
fputs(s, m_fp);
}
}
}
bool operator<(const Output* a)
{
return m_name < a->m_name;
}
void set_insertion_point(Output* insert);
void set_reference_start();
void set_reference_end();
bool do_insertion();
protected:
FILE* m_fp;
bool m_alive;
static bool m_tomem;
string m_name;
string m_fname;
string m_buffer;
vector<Insertion> m_insertions;
bool m_insertion_finished;
vector<Reference> m_references;
int m_reference_start;
int m_reference_start_line;
};
bool Output::m_tomem = true;
Output::~Output()
{
if (m_reference_start != -1) {
msg::error("reference started at line %d is not closed in tag '%s'",
m_reference_start_line, m_name.c_str());
throw MYFAILURE_INVALID_FORMAT;
}
if (!m_buffer.empty()) {
msg::verbose("flushing %s", m_fname.c_str());
fputs(m_buffer.c_str(), m_fp);
}
if (m_fp) {
fclose(m_fp);
}
}
void Output::set_insertion_point(Output* insert)
{
assert(insert!= NULL);
if (m_alive) {
Insertion i(insert, m_buffer.length());
m_insertions.push_back(i);
}
}
void Output::set_reference_start()
{
if (m_alive) {
if (m_reference_start != -1) {
msg::error("line %d: invalid reference_start appeared in tag context '%s'", input::lineno, m_name.c_str());
throw MYFAILURE_INVALID_FORMAT;
}
m_reference_start = m_buffer.length();
m_reference_start_line = input::lineno;
}
}
void Output::set_reference_end()
{
if (m_alive) {
if (m_reference_start == -1) {
msg::error("line %d: invalid reference_end appeared in tag context '%s'", input::lineno, m_name.c_str());
throw MYFAILURE_INVALID_FORMAT;
}
Reference ref(m_reference_start, m_buffer.length());
msg::verbose("%s reference_end: %d - %d", m_name.c_str(), ref.m_start, ref.m_end);
m_reference_start = -1;
m_references.push_back(ref);
}
}
bool Output::do_insertion()
{
if (!m_tomem || m_insertion_finished)
return true;
// to avoid infinite recursion by errornous commands,
// firstly declare we've finished this.
m_insertion_finished = true;
int upto = m_insertions.size();
for (int i = 0; i < upto; ++i) {
Insertion& ins = m_insertions[i];
assert(&ins);
if (ins.m_insert->m_references.size() == 0) {
msg::error("reference area is not specified or incorrect for tag '%s'", ins.m_insert->m_name.c_str());
return false;
}
if (!ins.m_insert->m_insertion_finished) {
if (!ins.m_insert->do_insertion())
return false;
}
Output* o = ins.m_insert;
for (int l = 0; l < o->m_references.size(); ++l) {
Reference& ref = o->m_references[l];
int len = ref.m_end - ref.m_start;
msg::verbose("%s [%d] inserting text at %d, %s(%d - %d)",
m_name.c_str(), l,
ins.m_insertion_point,
o->m_name.c_str(), ref.m_start, ref.m_start + len);
m_buffer.insert(ins.m_insertion_point,
o->m_buffer, ref.m_start,
len);
// fixup my insertions
int point = ins.m_insertion_point;
for (int k = 0; k < m_insertions.size(); ++k) {
if (m_insertions[k].m_insertion_point >= point) {
m_insertions[k].m_insertion_point += len;
msg::verbose("%s [%d] insertion point fixed from %d to %d",
m_name.c_str(), k,
m_insertions[k].m_insertion_point - len,
m_insertions[k].m_insertion_point);
}
}
// fixup my references
for (k = 0; k < m_references.size(); ++k) {
msg::verbose("%s m_reference[%d].m_start=%d, m_end=%d adding len=%d", m_name.c_str(),
k,
m_references[k].m_start, m_references[k].m_end,
len);
if (m_references[k].m_start > point) {
m_references[k].m_start += len;
}
if (m_references[k].m_end > point) {
m_references[k].m_end += len;
msg::verbose("finally start=%d, end=%d", m_references[k].m_start, m_references[k].m_end);
}
}
}
}
return true;
}
//////////////////////////////////////////////////////////////////////////
// class Divider
//
// this class manages the map of Output and performs misc. operations
//////////////////////////////////////////////////////////////////////////
class Divider : public map<string, Output*>
{
public:
virtual ~Divider()
{
// process insertions
for (iterator i = begin(); i != end(); ++i) {
if (!i->second->do_insertion())
break;
}
// clear up
for (i = begin(); i != end(); ++i) {
delete i->second;
}
}
//////////////////////////////////////////////////////////////////////////
// printout
//
// printout the argument to outputs
//////////////////////////////////////////////////////////////////////////
void printout(int c)
{
for (iterator i = begin(); i != end(); ++i) {
i->second->put(c);
}
}
void printout(const char* s)
{
for (iterator i = begin(); i != end(); ++i) {
i->second->puts(s);
}
}
void process_line(string& line);
protected:
void extract_version(const string& name, string& symbol, string& version, bool allow_omission = false);
void get_arg(const string& name, string& arg);
void prepare_section(string& name);
void process_divider(string& line);
void set_alive(bool alive)
{
for (iterator i = begin(); i != end(); ++i) {
i->second->setalive(alive);
}
}
typedef map<string, bool> OutputState;
void push_state(OutputState& state)
{
state.clear();
for (iterator i = begin(); i != end(); ++i) {
state[i->second->getname()] = i->second->getalive();
}
}
void pop_state(OutputState& state)
{
for (OutputState::iterator i = state.begin(); i != state.end(); ++i) {
assert((*this)[i->first] != NULL);
(*this)[i->first]->setalive(i->second);
}
}
protected:
string m_last_symbol;
string m_last_version;
};
void Divider::prepare_section(string& name)
{
// make it lower case
makelower(name);
if (name == id::internal) {
name = id::privatefile;
}
else if (name == id::public_) {
name = id::publicfile;
}
if (name != id::null && (*this)[name] == NULL) {
(*this)[name] = new Output(name);
}
}
//////////////////////////////////////////////////////////////////////////
// Divider::extract_version
//
// extracts version symbol and supported version
//
// "begin_symbol_version" is splited to symbol and version.
// Both are stored in upper case.
//////////////////////////////////////////////////////////////////////////
void Divider::extract_version(const string& name, string& symbol, string& version, bool allow_omission /*= false*/)
{
int nsymbol = name.find('_');
int nver = name.rfind('_');
if (nsymbol == -1 || nver == nsymbol) {
if (allow_omission) {
symbol = m_last_symbol;
version = m_last_version;
return;
}
else {
msg::error("line %d: invalid version specifier '%s'", input::lineno, name.c_str());
throw MYFAILURE_INVALID_FORMAT;
}
}
// symbol
symbol = name.substr(nsymbol + 1, nver - nsymbol - 1);
// upper case
makeupper(symbol);
version = "0000" + name.substr(nver + 1, name.length());
version = version.substr(version.length() - 4, 4);
makeupper(version);
m_last_symbol = symbol;
m_last_version = version;
}
//////////////////////////////////////////////////////////////////////////
// Divider::get_arg
//
// extracts one argument separated by "_"
//////////////////////////////////////////////////////////////////////////
void Divider::get_arg(const string& name, string& arg)
{
int npos = name.find('_');
if (npos == -1) {
msg::error("line %d: command incompleted in '%s'", input::lineno, name.c_str());
throw MYFAILURE_INVALID_FORMAT;
}
arg = name.substr(npos + 1, name.length());
}
//////////////////////////////////////////////////////////////////////////
// Divider::process_divider
//
// processes the divider instructions
//////////////////////////////////////////////////////////////////////////
void Divider::process_divider(string& line)
{
const char* p = line.begin();
++p;
bool makelive = true;
if (*p == '!') {
makelive = false;
++p;
}
// skip the heading spaces
while (isspace(*p))
++p;
for (int col = 0; p != line.end(); ++col) {
// pickup the name
string name;
while (*p != ';' && p != line.end()) {
if (!isspace(*p)) {
name += *p;
}
++p;
}
if (p != line.end()) {
++p;
}
// first column may have special meaning
if (col == 0) {
if (name == id::all) {
set_alive(makelive);
// does "!all" make sense ?
// however i'm supporting it anyway
break;
}
if (name == id::null) {
set_alive(!makelive);
break;
}
if (name.substr(0, id::insert_size) == id::insert) {
string insert;
get_arg(name, insert);
prepare_section(insert);
if (insert == id::null || insert == id::all) {
msg::error("line %d: invalid insertion of '%s'", input::lineno, insert.c_str());
throw MYFAILURE_INVALID_FORMAT;
}
assert((*this)[insert] != NULL);
for (iterator i = begin(); i != end(); ++i) {
(*this)[i->first]->set_insertion_point((*this)[insert]);
}
break;
}
if (name == id::reference_start) {
for (iterator i = begin(); i != end(); ++i) {
(*this)[i->first]->set_reference_start();
}
break;
}
if (name == id::reference_end) {
for (iterator i = begin(); i != end(); ++i) {
(*this)[i->first]->set_reference_end();
}
break;
}
if (name.substr(0, id::begin_size) == id::begin) {
string symbol;
string version;
extract_version(name, symbol, version);
printout("#if (");
printout(symbol.c_str());
printout(" >= 0x");
printout(version.c_str());
printout(")\n");
break;
}
if (name.substr(0, id::else_size) == id::else_) {
printout("#else\n");
break;
}
if (name.substr(0, id::end_size) == id::end) {
string symbol;
string version;
extract_version(name, symbol, version, true);
printout("#endif /* ");
printout(symbol.c_str());
printout(" >= 0x");
printout(version.c_str());
printout(" */\n");
break;
}
// setup the initial state
set_alive(!makelive);
}
prepare_section(name);
(*this)[name]->setalive(makelive);
}
}
//////////////////////////////////////////////////////////////////////////
// Divider::process_line
//
// handles one line
//////////////////////////////////////////////////////////////////////////
void Divider::process_line(string& line)
{
if (line[0] == ';') {
process_divider(line);
}
else {
// check if inline section appears
bool instr = false;
const char* p = line.begin();
const char* section = NULL;
while (p != line.end()) {
if (*p == '\\' && (p + 1) != line.end()) {
// skip escape character
// note: no consideration for Shift JIS
++p;
}
else if (*p == '"' || *p == '\'') {
// beginning of end of literal
instr = !instr;
}
else if (*p == '@' && !instr) {
// we have inline section
section = p;
break;
}
++p;
}
if (section) {
//
// if inline tag is specified, temporarily change
// the output
//
OutputState state;
push_state(state);
assert(*p == '@');
++p;
if (*p == '+') {
++p;
}
else {
set_alive(false);
}
while (p != line.end()) {
string name;
while (*p != ';' && p != line.end()) {
if (!isspace(*p)) {
name += *p;
}
++p;
}
if (p != line.end())
++p;
if (name == id::all) {
set_alive(true);
break;
}
if (name == id::null) {
set_alive(false);
break;
}
prepare_section(name);
(*this)[name]->setalive(true);
}
// trim trailing spaces
int i = section - line.begin() - 1;
while (i >= 0 && isspace(line[i])) {
--i;
}
line = line.substr(0, i + 1);
printout(line.c_str());
printout('\n');
pop_state(state);
}
else {
printout(line.c_str());
printout('\n');
}
}
++input::lineno;
}
//////////////////////////////////////////////////////////////////////////
// hdivide
//////////////////////////////////////////////////////////////////////////
void hdivide(FILE* fp)
{
Divider divider;
divider[id::publicfile] = new Output(id::publicfile);
divider[id::privatefile] = new Output(id::privatefile);
string line;
int c;
while ((c = getc(fp)) != EOF) {
if (c == '\n') {
divider.process_line(line);
line = "";
}
else {
line += (char)c;
}
}
if (!line.empty())
divider.process_line(line);
}
//////////////////////////////////////////////////////////////////////////
// main
//////////////////////////////////////////////////////////////////////////
int __cdecl main(int argc, char** argv)
{
int c;
while ((c = getopt(argc, argv, "v")) != EOF) {
switch (c) {
case 'v':
opt::verbose = true;
break;
default:
usage();
return EXIT_FAILURE;
}
}
if (optind == argc) {
usage();
return EXIT_FAILURE;
}
msg::verbose("input file: %s", argv[optind]);
FILE* fp = fopen(argv[optind], "rt");
if (fp == NULL) {
msg::error("cannot open input file %s", argv[optind]);
return EXIT_FAILURE;
}
input::length = _filelength(_fileno(fp));
id::publicfile = argv[optind];
id::publicfile = input::strip(id::publicfile.substr(0, id::publicfile.length() - 2));
id::privatefile = id::publicfile + "p";
int exitcode = EXIT_SUCCESS;
try {
hdivide(fp);
} catch (int err) {
exitcode = EXIT_FAILURE;
switch (err) {
case MYFAILURE_OPENFILE:
break;
case MYFAILURE_INVALID_FORMAT:
msg::error("fatal: invalid format");
break;
}
} catch (...) {
exitcode = EXIT_FAILURE;
}
fclose(fp);
return exitcode;
}