File contents
/*ident "@(#)G2++:compsrc/comp.c 3.1" */
/******************************************************************************
*
* C++ Standard Components, Release 3.0.
*
* Copyright (c) 1991, 1992 AT&T and Unix System Laboratories, Inc.
* Copyright (c) 1988, 1989, 1990 AT&T. All Rights Reserved.
*
* THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T and Unix System
* Laboratories, Inc. The copyright notice above does not evidence
* any actual or intended publication of such source code.
*
******************************************************************************/
// g2++comp - Compile g2++ record definitions
//
// g2++comp compiles the g2++ record definitions in one or
// more files. The files must have a ".g" suffix in their
// name to be considered. Each ".g" file is compiled into
// corresponding ".h" and ".c" files.
//
// g2++comp is an extension of g2comp, written by
// Jim Weythman.
////--------------------------------------------
//#include "compfns.h"
#ifdef __GNUG__
#pragma implementation "Map.h"
#endif
#include <Map.h>
#include <g2comp.h>
#include <g2ctype.h>
#include <g2debug.h>
#include <g2io.h>
#include <g2mach.h>
#include <ctype.h>
#define IOSTREAMH
#ifdef IOSTREAMH
#include <fstream.h>
#else
#include <iostream.h>
#endif
#include <stdlib.h>
#include <fcntl.h>
#include <time.h>
#include <iostream.h>
#include <String.h>
// Global data
extern String progname;
extern String filename;
extern int err;
extern G2NODE* stack[G2MAXDEPTH_ATTLC]; // should use a block
extern /*long*/time_t seed; // for ranstr()
extern G2BUF* gbuf; // global so transorm can grow gbuf->buf
extern G2NODE* head;
extern G2NODE* tail;
extern G2NODE nulldef;
extern G2NODE chardef;
extern G2NODE shortdef;
extern G2NODE longdef;
extern G2NODE stringdef;
extern G2BUF char_def;
extern G2BUF short_def;
extern G2BUF long_def;
extern G2BUF string_def;
struct mtbl{
G2BUF* buf;
mtbl* next;
};
extern mtbl* mtblhead;
extern mtbl* mtbltail;
#ifdef _MSC_VER
Mapdeclare(String,int)
extern Map(String,udt_info_ATTLC) udt_map_ATTLC;
extern Map(String,int) SoS;
#else
#ifdef __GNUG__
template class Map<String,udt_info_ATTLC>;
template class Map<String,int>;
#endif
extern Map<String,udt_info_ATTLC> udt_map_ATTLC;
extern Map<String,int> SoS;
#endif
// Local functions
mtbl* addtbl(G2BUF*);
void bdef(G2NODE* t, FILE* hf, FILE* cf);
void blockdef(G2NODE* t, FILE* hf, FILE* cf);
void bolt(const String& stem, FILE* hf, FILE* cf);
int dotg(const char*, const char *);
void errf(int level, const char* msg);
void errf(int level, const char* msg, const char* arg);
void errf(int level, const char* msg, const char* arg1,
const char* arg2);
void errf(int level, const char* msg, const char* arg1,
const char* arg2, const char* arg3);
void error(const char* msg);
void error(const char* msg, const char* a);
void error(const char* msg, const char* a, const char* b);
void error(const char* msg, const char* a, long b);
void extract_udt_info(G2NODE* gp);
void generate(G2NODE* t, FILE* hf, FILE* cf);
void gen_io(G2NODE* t, FILE* hf, FILE* cf);
void include_udt(FILE* f);
String lower(const String&);
void nullify(FILE*);
FILE* openfile(const String& filename);
void parse(const String& path, String& dir, String& stem);
String pathname(int level);
#ifdef IOSTREAMH
int perfile(ifstream&, const String& stem, const String& hfilename,
const String& cfilename);
#else
int perfile(istream&, const String& stem, const String& hfilename,
const String& cfilename);
#endif
void prologue(FILE* hf, FILE* cf, const String& stem,
const String& hfilename);
void prtbls(const String& stem, FILE* hf, FILE* cf);
String ranstr(int);
void remtbl();
void resettbl();
void show_udt_info(udt_info_ATTLC x);
void show_udt_map();
void sizealign(FILE* cf);
void transform(G2NODE* p);
int valid(int level, G2NODE* gp);
void valid1(int, G2NODE*);
void wrap(FILE*);
unsigned do_checksum(const char *);
////--------------------------------------------
#ifdef _MSC_VER
Map(String,udt_info_ATTLC) udt_map_ATTLC;
Map(String,int) SoS;
#else
Map<String,udt_info_ATTLC> udt_map_ATTLC;
Map<String,int> SoS;
#endif
mtbl* mtblhead=0;
mtbl* mtbltail=0;
String progname;
String filename;
int err;
G2NODE* stack[G2MAXDEPTH_ATTLC]; // should use a block
/*long*/time_t seed; // for ranstr()
G2BUF* gbuf; // global so transorm can grow gbuf->buf
G2NODE* head;
G2NODE* tail;
G2NODE nulldef;
G2NODE chardef;
G2NODE shortdef;
G2NODE longdef;
G2NODE stringdef;
G2BUF char_def;
G2BUF short_def;
G2BUF long_def;
G2BUF string_def;
int no_cap_flag = 0;
int vblock_flag = 0;
main(int argc, char* argv[]){
String stem;
String dir;
int i;
// int tflag = 0;
// int Tflag = 0;
#ifdef IOSTREAMH
// ifstream ins; // input fstream
#else
FILE* f_file;
#endif
char *cur_suffix = ".g";
progname = argv[0];
seed = time(0);
// srand((unsigned)seed);
// Initialize table of G2NODE
resettbl();
// Loop over .g arguments in command line
for(i = 1; i < argc; i++){
if(strcmp(argv[i],"-n") == 0) {
// the -n option causes g2++comp to refrain from
// converting typenames to all uppercase in the
// generated code
no_cap_flag = 1;
continue;
}
if(strcmp(argv[i],"-s") == 0) {
// the -s option affects the code that is generated
// for simple types (G2++ types that are not structures)
// Arrays will be derived from Vblock<XXX>, character
// strings will be derived from String, and the integer-based
// types (long, short, char) will have special class code
// generated
vblock_flag = 1;
continue;
}
if(strcmp(argv[i],"-g") == 0) {
cur_suffix = "";
continue;
}
if(strncmp(argv[i],"-g",2) == 0) {
cur_suffix = &argv[i][2];
continue;
}
if(!dotg(argv[i], cur_suffix)){
continue;
}
#ifdef IOSTREAMH
ifstream ins(argv[i],ios::in);
if(!ins){
error("cannot open '%s': ", argv[i]);
perror("");
err++;
continue;
}
#else
if ((f_file = fopen(argv[i],"r")) == NULL) {
error("cannot open '%s': ", argv[i]);
perror("");
err++;
continue;
}
istream ins(f_file);
#endif
srand(do_checksum(argv[i]));
filename = String(argv[i]); // might be "a/b/c/d.g"
DEBUG(cerr << "in main, filename=" << filename << "\n" ;)
// Display the filename on stderr
fprintf(stderr, "%s:\n", (const char*)filename);
// Extract directory part of the filename into 'dir'
// and file part (less .g) into 'stem'
parse(
filename, // might be a/b/c/d.g
dir, // would be a/b/c
stem // would be d
);
DEBUG(cerr << "on return from parse:\n" << " dir=" << dir << "\n"
<< " stem=" << stem << "\n" ;)
// We will put the .h and .c files in the current directory
String hfilename = /* dir + "/" + */ stem + ".h";
#if defined(_MSC_VER) || defined(__TCPLUSPLUS__)
String cfilename = /* dir + "/" + */ stem + ".cpp";
#else
String cfilename = /* dir + "/" + */ stem + ".c";
#endif
DEBUG(cerr << " hfilename=" << hfilename << "\n" ;)
DEBUG(cerr << " cfilename=" << cfilename << "\n" ;)
// Do it
if(perfile(ins,stem,hfilename,cfilename)){
// Success! Display the rest of the message to user
#if defined(_MSC_VER) || defined(__TCPLUSPLUS__)
fprintf(stderr, " => %s.h, %s.cpp\n", (const char*)stem, (const char*)stem);
#else
fprintf(stderr, " => %s.[hc]\n", (const char*)stem);
#endif
}
// Prepare to process the next .g file
ins.close();
resettbl();
}
return err;
}
int
valid(int level, G2NODE* gp){
DEBUG(cerr << "enter valid with level=" << level << "\n" ;)
int saverr = err;
valid1(level, gp);
return err - saverr;
}
void
valid1(int level, G2NODE* gp){
stack[level] = gp;
DEBUG(cerr << "enter valid1 with level = " << level << ", gp = " << "\n" ;)
DEBUG( showtree_ATTLC(gp,0); )
String temp=g2name_ATTLC(gp); // elim "sorry not implemented"
DEBUG( cerr << "temp = " << temp << endl; )
DEBUG(
cerr << "stack contains:" << endl;
for(int k = 0;k<=level;k++){
cerr << " " << g2name_ATTLC(stack[k]) << endl;
}
)
if(level<=0 && !isname_ATTLC(temp) ){
errf(level, " root is not a name\n");
err++;
return;
}
if(isname_ATTLC(temp)){
G2NODE* next=g2next_ATTLC(gp);
if(next){
temp=g2name_ATTLC(next);
if(!temp.is_empty() && isint_ATTLC(temp)){
stack[level] = next;
errf(level, " mixed names and indexes\n");
err++;
}
}else{
// Check for variable size String declared at level zero
// and issue initial allocation warning message
temp = g2val_ATTLC(gp);
const char* pn = (const char*)temp;
int n = atoi(pn);
DEBUG( cerr << "max size = " << n << endl; )
if(n == 0 && temp.length() >= 4 && temp.char_at(1) == '('){
n = atoi(pn+2);
}
DEBUG( cerr << "initial capacity = " << n << endl; )
if(n > 0 && level==0){
if (vblock_flag == 0) {
String nn = int_to_str(n);
String type = upper(
g2name_ATTLC(stack[0])
);
errf(
level,
" warning: %s will not be\nused as the initial string size;for proper preallocation,\nuse a constructor argument, e.g. %s x(Stringsize(%s));\n --> or use the -s option\n",
(const char*)nn,
(const char*)type,
(const char*)nn
);
}
}
}
}else if(isdigit_ATTLC(temp.char_at(0))){
// Array
//
// Remember: all arrays should be at level 0,
// so we should now be at level 1 looking at the
// size info.
DEBUG(cerr << "array" << endl; )
G2NODE* next=g2next_ATTLC(gp);
if(next){
stack[level] = next;
if(isint_ATTLC(g2name_ATTLC(next))){
errf(level, " only one dimension allowed per level\n");
}else{
errf(level, " mixed names and indexes\n");
}
err++;
}else{
// Decode size and initial allocation information
const char* pn = (const char*)temp;
int n = atoi(pn);
DEBUG( cerr << "max size = " << n << endl; )
if(n == 0 && temp.length() >= 4 && temp.char_at(1) == '('){
n = atoi(pn+2);
}
DEBUG( cerr << "initial capacity = " << n << endl; )
if(n > 0){
String pval = g2val_ATTLC(stack[level-1]);
DEBUG( cerr << "level, pval = " << level << ", " << pval << endl; )
if(level==1 && pval != "HOISTED"){
DEBUG(cerr << "level==1 && pval!=HOISTED" << endl;)
// Corrective action: use a constructor argument
if (vblock_flag == 0) {
String nn = int_to_str(n);
String type = upper(g2name_ATTLC(stack[0]));
errf(
level,
" warning: %s will not be\nused as the initial array capacity; for proper preallocation,\nuse a constructor argument, e.g. %s x(%s);\n --> or use the -s option\n",
(const char*)nn,
(const char*)type,
(const char*)nn
);
}
}else{
// level>1 || (level==1 && pval == HOISTED)
// Corrective action: modify record structure
DEBUG( cerr << "level>1 || (level==1 && pval == HOISTED)" << endl; )
#if 0
String nn = int_to_str(n);
errf(
level,
" warning: %s will not be used as the initial array capacity; consider making this array the member of a structure\n",
(const char*)nn
);
#endif
}
}
// Issue warning for array elements declared as n or 0(n)
pn = (const char*)gp->val;
n = atoi(pn);
DEBUG( cerr << "max size = " << n << endl; )
if(n == 0 && gp->val.length() >= 4 &&
gp->val.char_at(1) == '('){
n = atoi(pn+2);
}
DEBUG( cerr << "initial capacity = " << n << endl; )
#if 0
if(n > 0){
DEBUG(cerr << "n>0: issue array element warning" << endl;)
char buf[10];
sprintf(buf,"%d",n);
errf(level, " warning: %s will not be used as the initial string capacity; consider redefining the element type as a structure\n",buf);
}
#endif
}
}else{
errf(level, " name is neither a name nor an index\n");
err++;
}
temp=g2val_ATTLC(gp);
if(temp.is_empty() && !g2child_ATTLC(gp)){
errf(level, " missing value\n");
err++;
}
if(!g2child_ATTLC(gp)){
temp=g2val_ATTLC(gp);
DEBUG(cerr << "gp has no children; set temp=" << temp << "\n" ;)
if(!isdigit_ATTLC(temp.char_at(0))){
// Cludge -- prevent user from saying "STRING"
if(temp=="STRING"){
errf(level, " type '%s' not defined\n", (const char*)temp);
err++;
}else{
if(!lookup(temp) ){
if(!udt_map_ATTLC.element(temp)){
errf(level, " type '%s' not defined\n",
(const char*)temp);
err++;
}
}
}
}
}
DEBUG( cerr << "ready to call valid1 recursively for children" << endl; )
for(G2NODE* cp=g2child_ATTLC(gp); cp; cp=g2next_ATTLC(cp)){
valid1(level+1,cp);
}
}
void
errf(int level, const char* msg){
fprintf(stderr, "%s: ", (const char*)progname);
if(filename.length()>0){
fprintf(stderr, "file '%s': ", (const char*)filename);
}
fprintf(stderr, "path '%s'", (const char*)pathname(level));
fprintf(stderr, msg);
}
void
errf(int level, const char* msg, const char* arg){
fprintf(stderr, "%s: ", (const char*)progname);
if(filename.length()>0){
fprintf(stderr, "file '%s': ", (const char*)filename);
}
fprintf(stderr, "path '%s'", (const char*)pathname(level));
fprintf(stderr, msg, arg);
}
void
errf(int level, const char* msg, const char* arg1, const char* arg2){
fprintf(stderr, "%s: ", (const char*)progname);
if(filename.length()>0){
fprintf(stderr, "file '%s': ", (const char*)filename);
}
fprintf(stderr, "path '%s'", (const char*)pathname(level));
fprintf(stderr, msg, arg1, arg2);
}
void
errf(int level, const char* msg, const char* arg1, const char* arg2,
const char* arg3){
fprintf(stderr, "%s: ", (const char*)progname);
if(filename.length()>0){
fprintf(stderr, "file '%s': ", (const char*)filename);
}
fprintf(stderr, "path '%s'", (const char*)pathname(level));
fprintf(stderr, msg, arg1, arg2, arg3);
}
String
pathname(int level){
String result="";
for(int i = 0; i <= level; i++){
String name;
if(g2val_ATTLC(stack[i]) == "HOISTED"){
name = "?";
}else{
name=g2name_ATTLC(stack[i]);
}
result+=name;
if(i<level){
result += ".";
}
}
return result;
}
String
upper(const String& s){
String result(Stringsize(s.length()));;
if (no_cap_flag) {
result = s;
}
else {
for( int i=0;i<s.length();i++ ){
if( islower(s.char_at(i)) ){
result += toupper(s.char_at(i));
}else{
result += s.char_at(i);
}
}
}
return result;
}
G2NODE*
lookup(const String& name){
if(isdigit_ATTLC(name.char_at(0))){ // optimization
return NULL;
}
DEBUG(cerr << "enter lookup with name=" << name << "\n" ;)
for(mtbl* mp = mtblhead; mp; mp = mp->next){
/* DEBUG(cerr << "consider buffer at address "
<< long(mp) << "\n" ;)
*/
for(G2NODE* t=g2root_ATTLC(mp->buf); t; t=g2next_ATTLC(t)){
/* DEBUG(cerr << "consider G2NODE t:\n";)
DEBUG(shownode_ATTLC(t);)
DEBUG(cerr << "g2name_ATTLC(t)="
<< g2name_ATTLC(t) << "\n" ;)
*/
if(name == g2name_ATTLC(t)){
DEBUG(cerr << "hit!\n";)
return t;
}
}
DEBUG(cerr << "exit from inner forloop\n";)
}
DEBUG(cerr << "lookup failed!\n";)
return NULL;
}
void
error(const char* msg){
fprintf(stderr, "%s: ", (const char*)progname);
#ifdef _MSC_VER
if( filename != "" ){
#else
if( filename ){
#endif
fprintf(stderr, "file '%s': ", (const char*)filename);
}
fprintf(stderr, msg);
}
void
error(const char* msg, const char* a){
fprintf(stderr, "%s: ", (const char*)progname);
#ifdef _MSC_VER
if( filename != "" ){
#else
if( filename ){
#endif
fprintf(stderr, "file '%s': ", (const char*)filename);
}
fprintf(stderr, msg, a);
}
void
error(const char* msg, const char* a, const char* b){
fprintf(stderr, "%s: ", (const char*)progname);
#ifdef _MSC_VER
if( filename != "" ){
#else
if( filename ){
#endif
fprintf(stderr, "file '%s': ", (const char*)filename);
}
fprintf(stderr, msg, a, b);
}
void
error(const char* msg, const char* a, long b){
fprintf(stderr, "%s: ", (const char*)progname);
#ifdef _MSC_VER
if( filename != "" ){
#else
if( filename ){
#endif
fprintf(stderr, "file '%s': ", (const char*)filename);
}
fprintf(stderr, msg, a, b);
}
FILE*
openfile(const String& filename){
DEBUG(cerr << "enter openfile with filename=" << filename << "\n" ;)
FILE* result=fopen(filename, "w");
if(result == NULL){
error("cannot open '%s': ", (const char*)filename);
perror("");
err++;
}
return result;
}
int
dotg(const char *name, const char *suffix){
// screen out files w/o '.g' suffix
if(suffix == 0 || strcmp(suffix, "") == 0) return 1;
int suflen = strlen(suffix);
if(strlen(name) <= suflen || strcmp(name+strlen(name)-suflen,suffix)){
error("skipping '%s'; doesn't have a '%s' suffix\n", name, suffix);
err++;
return 0;
}
return 1;
}
void
parse(
// Parse directory part of path into 'dir'
// and file part (less '.g') into 'stem'
const String& path, // could be a/b/c/d.g
String& dir, // would be a/b/c
String& stem // would be d
){
DEBUG(cerr << "enter parse with path=" << path << "\n" ;)
int index = path.length()-1;
while(index>=0){
#if defined(_MSC_VER) || defined(__TCPLUSPLUS__)
if(path[index]=='/' || path[index]=='\\'){
#else
if(path[(unsigned) index]=='/'){
#endif
break;
}
index--;
}
DEBUG(cerr << "break from loop with index=" << index << "\n" ;)
if(index<0){
dir="";
}else{
dir=path.chunk(0,index);
}
DEBUG(cerr << "dir=" << dir << "\n" ;)
stem = path.chunk(
index+1, // starting character
path.length()-index-3 // number of characters
);
DEBUG(cerr << "stem=" << stem << "\n" ;)
}
#ifdef _MSC_VER
Mapimplement(String,udt_info_ATTLC)
Mapimplement(String,int)
#endif
////--------------------------------------------
//#include "compfns.h"
void
prologue(FILE* hf, FILE* cf, const String& stem, const String& hfilename){
DEBUG(cerr << "enter prologue with stem=" << stem << "\n" << "hfilename="
<< hfilename << "\n" ;)
fprintf(hf, "#include <String.h>\n");
fprintf(hf, "#include \"Vblock.h\"\n");
#if defined(_MSC_VER) || defined(__TCPLUSPLUS__)
fprintf(hf, "#include \"g2.h\"\n\n");
#else
fprintf(hf, "#include \"g2++.h\"\n\n");
#endif
fprintf(hf, "class istream;\nclass ostream;\n\n");
fprintf(hf, "typedef int %sTYPE;\n", (const char*)upper(stem));
fprintf(hf, "typedef long LONG;\n");
fprintf(hf, "typedef char CHAR;\n");
fprintf(hf, "typedef short SHORT;\n");
fprintf(hf, "typedef String STRING;\n");
fprintf(hf, "\n");
fflush(hf); // Debug
// Write necessary #include's to cf
#ifdef __GNUG__
fprintf(cf, "#ifdef __GNUG__\n");
fprintf(cf, "#pragma implementation \"Vblock.h\"\n");
fprintf(cf, "#pragma implementation \"Block.h\"\n");
fprintf(cf, "#endif\n");
#endif
fprintf(cf, "#include \"%s\"\n", (const char*)hfilename);
fprintf(cf, "#include \"g2desc.h\"\n");
fprintf(cf, "#include \"g2inline.h\"\n");
fprintf(cf, "#include \"g2io.h\"\n");
fprintf(cf, "#include \"g2mach.h\"\n");
#if defined(_MSC_VER) || defined(__TCPLUSPLUS__)
fprintf(cf, "#include <iostream.h>\n");
#else
fprintf(cf, "#include <stream.h>\n");
#endif
fprintf(cf, "\n");
fflush(cf); // Debug
// Generate declaration for array used to hold intermediate
// alignment expressions in constructors
fprintf(cf,"static int align_val[%d];\n",G2MAXDEPTH_ATTLC);
}
int
#ifdef IOSTREAMH
perfile(ifstream& ins, const String& stem, const String& hfilename,
const String& cfilename){
#else
perfile(istream& ins, const String& stem, const String& hfilename,
const String& cfilename){
#endif
FILE* hf;
FILE* cf;
// Use untyped I/O to extract information from
// g2 record definitions in ifstream 'ins'
// G2NODE* root;
G2NODE* t;
mtbl* mp;
mtbl* first = 0;
int OK = 1;
for(;;){
// Get a new buffer
if(!(gbuf=new G2BUF)){
error("out of memory\n");
exit(1);
}
if(!getbuf_ATTLC(gbuf,ins)){
DEBUG(cerr << "getbuf_ATTLC returns EOF -- break\n";)
break;
}
DEBUG(cerr << "in perfile, getbuf_ATTLC returns *gbuf=\n";)
DEBUG(showbuf_ATTLC(gbuf);)
if( gbuf->root->val == "USER" ){
DEBUG(cerr << "USER type!\n";)
// This is a USER type: store info in udt_map_ATTLC.
//
// Note: I tried to do this in a more uniform
// fashion (treating user-defined type as an
// ordinary type definition (linking it into
// mtbl, etc.), and ran into lots of problems.
// Now, all information is stored in a separate
// table, udt_map_ATTLC.
extract_udt_info(gbuf->root);
}else{
DEBUG(cerr << "ordinary record type\n";)
// Transform the type tree rooted at gbuf->root:
//
// o Hoist array types to level 0
// o Change string and block definitions
// o Generate structure tags for anonymous structures
// Begin debug:
DEBUG(cerr << "before calling transform, ";)
DEBUG(cerr << "list of type trees=\n";)
DEBUG(
for(t=gbuf->root; t; t=t->next){
showtree_ATTLC(t,0);
}
)
// End debug
head=tail=0;
transform(gbuf->root);
// Debug: display the list of hoisted types
G2NODE* ptr=tail;
DEBUG(cerr << "tail:\n";)
while( ptr ){
DEBUG(showtree_ATTLC(ptr,1);)
ptr=ptr->next;
DEBUG(cerr << "tail->next:\n";)
}
// If any array types were hoisted, append the original
// type definition to the end of the chain
if( tail ){
DEBUG(cerr << "append the original typedef to the end\n";)
tail->next = gbuf->root;
/*root =*/ gbuf->root = head;
}
// Begin debug
DEBUG(cerr << "after calling transform, ";)
DEBUG(cerr << "list of type trees=\n";)
DEBUG(for(t=gbuf->root; t; t=t->next){
DEBUG(showtree_ATTLC(t,0);)
})
// End debug
// Link this G2BUF into the mtblhead list
// Note: this was done previously AFTER checking the
// types. Now we must remove the buffer from the mtbl
// list before deleting it whenever errors are found.
DEBUG(cerr << "ready to call addtbl\n";)
if(first==0){
DEBUG(cerr << "first call to addtbl\n";)
first = addtbl(gbuf);
DEBUG(cerr << "addtbl returns:\n";)
DEBUG(showbuf_ATTLC(first->buf);)
}else{
DEBUG(cerr << "subsequent call to addtbl\n";)
addtbl(gbuf);
}
DEBUG(cerr << "on return from addtbl, mtblhead-> =\n";)
// Begin debug
DEBUG(for(mp=mtblhead; mp; mp=mp->next){
DEBUG(cerr << "->\n";)
DEBUG(showbuf_ATTLC(mp->buf);)
})
// End debug
// Check the types...
DEBUG(cerr << "Check the types\n";)
int ok=1;
for(t=gbuf->root; t; t=t->next){
// t->name=lower(t->name);
// ...for typename clashes...
DEBUG(cerr << "...for typename clashes...\n";)
DEBUG(cerr
<< "ready to call lookup with t->name = "
<< t->name
<< "\n"
;)
if(lookup(t->name)!=t){
error("duplicate record: '%s'\n", (const char*)t->name);
err++;
ok=0;
}
// ...and for well-formedness of the definition
DEBUG(cerr << "and for well-formedness of the definition\n";)
DEBUG(cerr << "ready to call valid\n";)
int temp=valid(0,t);
DEBUG(cerr << "valid returns " << temp << "\n" ;)
ok &= (temp==0);
}
DEBUG(cerr << "exit from check-ok loop with ok=" << ok << "\n" ;)
if(!ok){
DEBUG(cerr << "ready to call remtbl\n";)
remtbl();
// Begin debug
DEBUG(cerr << "after remtbl(), mtblhead-> =\n";)
DEBUG(for(mp=mtblhead; mp; mp=mp->next){
DEBUG(cerr << "->\n";)
DEBUG(showbuf_ATTLC(mp->buf);)
})
// End debug
delete gbuf;
}
OK &= ok;
}
}
DEBUG(cerr << "exit from getbuf_ATTLC-loop with OK = " << OK << "\n";)
if(!OK){
// Do not generate code if errors were found
return 0;
}else{
// ***********************************************
// * *
// * BEGIN CODE GENERATION *
// * *
// ***********************************************
// Debug: display the list of G2BUF's
DEBUG(cerr << "mtbl list=\n";)
DEBUG(for(mp = mtblhead; mp; mp = mp->next){
cerr << "->\n";
showbuf_ATTLC(mp->buf);
})
// Open hfilename for output, setting file pointer hf
if((hf=openfile(hfilename))==NULL){
return 0;
}
// Open cfilename for output, setting file pointer cf
if((cf=openfile(cfilename))==NULL){
return 0;
}
// Write header file guard to protect against multiple
// inclusion
fprintf(hf, "#ifndef %sH\n#define %sH\n\n",
(const char*)upper(stem),
(const char*)upper(stem));
// Generate the prologue at beginning of .h and .c files
prologue(hf,cf,stem,hfilename);
// For each user-defined type in udt_map_ATTLC, generate
// the appropriate #include directives.
//
// Note: include_udt(), sizealign(), wrap(), and
// nullify() should be bundled into one routine.
DEBUG(cerr << "ready to call include_udt\n";)
include_udt(hf);
// For each user-defined type T in udt_map_ATTLC, generate
// size and alignment constants (these are used in
// size and offset computations -- see desc2)
DEBUG(cerr << "ready to call sizealign\n";)
sizealign(cf);
// For each user-defined type T in udt_map_ATTLC, generate
// x_put_T and x_get_T wrappers for the client-provided
// I/O routines.
DEBUG(cerr << "ready to call wrap\n";)
wrap(cf);
// For each user-defined type T in udt_map_ATTLC, generate
// nullify() and isnull() routines that can be called
// through a pointer by g2clear().
DEBUG(cerr << "ready to call nullify\n";)
nullify(cf);
// Generate everything else on a type-by-type basis.
DEBUG(cerr << "Generate everything else on a type-by-type basis\n";)
for(mp = first; mp; mp = mp->next){
gbuf = mp->buf;
for(t=gbuf->root; t; t=t->next){
DEBUG(cerr << "consider tree:\n";)
DEBUG(showtree_ATTLC(t,0);)
DEBUG(cerr << "ready to call generate\n";)
generate(t,hf,cf);
if(t->next){
DEBUG(cerr << "this is a hoisted type\n";)
// This is a hoisted type; generate a
// Vblockdeclare/Vblockimplement pair.
#ifdef __GNUG__
blockdef(t,hf,cf);
#endif
}
}
}
// Bolt the .c file and the .h file together
bolt(stem,hf,cf);
// Closing endif for file guard
fprintf(hf, "\n#endif\n");
// Close the files
fclose(hf);
fclose(cf);
// Return success
return 1;
}
}
void
extract_udt_info(G2NODE* t){
DEBUG(cerr << "enter extract_udt_info with *t=\n";)
DEBUG(showtree_ATTLC(t,0);)
udt_info_ATTLC x;
// Assume most user-defined types will name five
// or fewer header files
x.headers.size(5);
#ifdef _MSC_VER
if(((void *) udt_map_ATTLC.element(g2name_ATTLC(t))) != 0){
#else
if(udt_map_ATTLC.element(g2name_ATTLC(t))){
#endif
// This type has been defined earlier!
error("duplicate user-defined type %s ignored\n",
(const char*)g2name_ATTLC(t));
}else{
// Set defaults (may be overridden by attributes)
x.headers[0] = g2name_ATTLC(t) + ".h";
x.null = g2name_ATTLC(t) + "()";
x.isnull="";
x.put="operator<<";
x.get="operator>>";
// Get attributes
int header_count=0;
int put_count=0;
int get_count=0;
int null_count=0;
int isnull_count=0;
for(G2NODE* c=g2achild_ATTLC(t); c; c=g2anext_ATTLC(c)){
DEBUG(cerr << "consider attribute child:\n";)
DEBUG(shownode_ATTLC(c);)
if(g2name_ATTLC(c) == ".header"){
DEBUG(cerr << "header\n";)
if(header_count==x.headers.size()){
x.headers.size(2*x.headers.size());
}
if (g2val_ATTLC(c) == "") {
error("missing file name (or missing tab character) in .header statement for %s\n", g2name_ATTLC(t));
}
x.headers[header_count++]=g2val_ATTLC(c);
}else if(g2name_ATTLC(c) == ".get"){
DEBUG(cerr << "get\n";)
if(++get_count>1){
fprintf(stderr,
"file %s: user-defined type %s: duplicate get attribute\n",
(const char*)filename,
(const char*)t->name);
}else{
x.get=g2val_ATTLC(c);
}
}else if(g2name_ATTLC(c) == ".put"){
DEBUG(cerr << "put\n";)
if(++put_count>1){
fprintf(stderr,
"file %s: user-defined type %s: duplicate put attribute\n",
(const char*)filename,
(const char*)t->name);
}else{
x.put=g2val_ATTLC(c);
}
}else if(g2name_ATTLC(c) == ".null"){
DEBUG(cerr << "null\n";)
if(++null_count>1){
fprintf(stderr,
"file %s: user-defined type %s: duplicate null attribute\n",
(const char*)filename,
(const char*)t->name);
}else{
x.null=g2val_ATTLC(c);
}
}else if(g2name_ATTLC(c) == ".isnull"){
DEBUG(cerr << "isnull\n";)
if(++isnull_count>1){
fprintf(stderr,
"file %s: user-defined type %s: duplicate isnull attribute\n",
(const char*)filename,
(const char*)t->name);
}else{
x.isnull=g2val_ATTLC(c);
}
}
}
if(header_count==0){
header_count=1; // the default;
}
x.header_count=header_count;
DEBUG(cerr << "after for loop, x=\n";)
DEBUG(show_udt_info(x);)
// Store x in udt_map_ATTLC
DEBUG(cerr << "ready to store x in udt_map_ATTLC\n";)
udt_map_ATTLC[g2name_ATTLC(t)]=x;
DEBUG(cerr << "ready to return\n";)
}
}
////--------------------------------------------
//#include "compfns.h"
void
show_udt_info(udt_info_ATTLC x){
int nheaders=x.header_count;
DEBUG(cerr << "nheaders=" << nheaders << "\n" ;)
for(int k=0; k < nheaders; k++){
DEBUG(cerr << x.headers[k] << "\n";)
}
DEBUG(cerr << ".put=" << x.put << "\n" << ".get=" << x.get
<< "\n" << ".null=" << x.null << "\n" << ".isnull=" << x.isnull
<< "\n" ;)
}
void
show_udt_map(){
#ifdef _MSC_VER
Mapiter(String,udt_info_ATTLC) i(udt_map_ATTLC);
#else
Mapiter<String,udt_info_ATTLC> i(udt_map_ATTLC);
#endif
DEBUG(cerr << "udt_map_ATTLC:\n";)
while(++i){
DEBUG(cerr << " " << i.key() << "\t" << "(" ;)
DEBUG(udt_info_ATTLC x = i.value();)
DEBUG(cerr << ",";)
DEBUG(show_udt_info(x);)
DEBUG(cerr << ")";)
}
}
void
sizealign(FILE* cf){
// Generate size and alignment constants for
// each user-defined type in udt_map_ATTLC
#ifdef _MSC_VER
Mapiter(String,udt_info_ATTLC) i(udt_map_ATTLC);
#else
Mapiter<String,udt_info_ATTLC> i(udt_map_ATTLC);
#endif
while(++i){
fprintf(cf,
"static struct x%s{\n char base[1];\n %s x;\n}x%s;\n\n",
(const char*)i.key(), (const char*)i.key(), (const char*)i.key());
fprintf(cf,
"static const int %s_SIZE=sizeof(%s);\n",
(const char*)i.key(), (const char*)i.key());
fprintf(cf,
"static const char* %s_ALIGN_SIMPLIFY_EXPRESSION=(char*)(&x%s.x);\n",
(const char*)i.key(), (const char*)i.key());
// fprintf(cf,
// "static const int %s_ALIGN=%s_ALIGN_SIMPLIFY_EXPRESSION-x%s.base;\n\n",
// (const char*)i.key(), (const char*)i.key(), (const char*)i.key());
fprintf(cf,
"static int get_%s_ALIGN() {\n return(%s_ALIGN_SIMPLIFY_EXPRESSION-x%s.base); }\n\n",
(const char*)i.key(), (const char*)i.key(), (const char*)i.key());
}
}
void
include_udt(FILE* hf){
#ifdef _MSC_VER
Mapiter(String,udt_info_ATTLC) i(udt_map_ATTLC);
#else
Mapiter<String,udt_info_ATTLC> i(udt_map_ATTLC);
#endif
DEBUG(cerr << "enter include_udt\n";)
while(++i){
udt_info_ATTLC x=i.value();
DEBUG(cerr << "in while loop, x=\n";)
DEBUG(show_udt_info(x);)
for(int j=0;j<x.header_count;j++){
DEBUG(cerr << "in j loop, consider header " << x.headers[j]
<< "\n" ;)
fprintf(hf, "#include \"%s\"\n", (const char*)x.headers[j]);
}
}
DEBUG(cerr << "ready to return from include_udt\n";)
}
void
wrap(FILE* cf){
#ifdef _MSC_VER
Mapiter(String,udt_info_ATTLC) i(udt_map_ATTLC);
#else
Mapiter<String,udt_info_ATTLC> i(udt_map_ATTLC);
#endif
DEBUG(cerr << "enter wrap\n";)
while(++i){
String name=i.key();
DEBUG(cerr << "in while loop, i.key()=" << name << "\n" ;)
udt_info_ATTLC x=i.value();
DEBUG(cerr << "...and i.value()=\n";)
DEBUG(show_udt_info(x);)
if(x.put == "operator<<"){
fprintf(cf,
"static ostream& x_put_%s(ostream& os,const void* vp){\n",
(const char*)name);
fprintf(cf, " return os << *(%s*)vp;\n}\n",
(const char*)name);
}else{
fprintf(cf,
"static ostream& x_put_%s(ostream& os,const void* vp){\n",
(const char*)name);
fprintf(cf, " return %s(os,*(%s*)vp);\n}\n",
(const char*)x.put,
(const char*)name);
}
if(x.get == "operator>>"){
fprintf(cf,
"static istream& x_get_%s(istream& is,void* vp){\n",
(const char*)name);
fprintf(cf, " return is >> *(%s*)vp;\n}\n",
(const char*)name);
}else{
fprintf(cf,
"static istream& x_get_%s(istream& is,void* vp){\n",
(const char*)name);
fprintf(cf, " return %s(is,*(%s*)vp);\n}\n",
(const char*)x.get,
(const char*)name);
}
}
}
void
nullify(FILE* cf){
#ifdef _MSC_VER
Mapiter(String,udt_info_ATTLC) i(udt_map_ATTLC);
#else
Mapiter<String,udt_info_ATTLC> i(udt_map_ATTLC);
#endif
DEBUG(cerr << "enter nullify\n";)
while(++i){
String name=i.key();
udt_info_ATTLC x=i.value();
// fprintf(cf, "static %s null_%s=%s;\n",
// (const char*)name,
// (const char*)name,
// (const char*)x.null);
if (x.null != "") {
fprintf(cf, "static %s& null_%s(){\n static %s nval = %s; return nval;}\n",
(const char*)name,
(const char*)name,
(const char*)name,
(const char*)x.null);
}
else {
fprintf(cf, "static %s& null_%s(){\n static %s nval; return nval;}\n",
(const char*)name,
(const char*)name,
(const char*)name);
}
fprintf(cf,
// "static void %s_nullify(void* vp){\n *(%s*)vp=null_%s;\n}\n",
"static void %s_nullify(void* vp){\n *(%s*)vp=null_%s();\n}\n",
(const char*)name,
(const char*)name,
(const char*)name);
String result;
if( x.isnull.is_empty() ){
// result = "*(" + name + "*)vp==null_" + name;
result = "*(" + name + "*)vp==null_" + name + "()";
}else{
result = x.isnull + "(*(" + name + "*)vp)";
}
fprintf(cf,
"static int %s_is_null(void* vp){\n return %s;\n}\n",
(const char*)name,
(const char*)result);
}
}
void
bdef(G2NODE* t, FILE* hf, FILE* cf){
DEBUG(cerr << "enter bdef with t=\n";)
DEBUG(showtree_ATTLC(t,1);)
// Visit t's children
for(G2NODE* cp=t->child; cp; cp=cp->next){
DEBUG(cerr << "ready to visit t's next child\n";)
bdef(cp,hf,cf);
}
// Then visit t
DEBUG(cerr << "exit from children loop; now visit t itself\n";)
DEBUG(showtree_ATTLC(t,1);)
if(isdigit_ATTLC(t->name.char_at(0))){
// t is an array (note: all arrays have
// been transformed into terminal arrays)
DEBUG( cerr << "t->name is a digit: t is an array\n"; )
String a_typename;
if(isdigit_ATTLC(t->val.char_at(0))){
a_typename = "STRING";
}else{
a_typename = upper(t->val);
}
DEBUG(cerr << "t's typename is " << a_typename << "\n" ;)
#ifdef _MSC_VER
// Invoke vblockdeclare macro
DEBUG(cerr << "put to .h file:\n ***Vblockdeclare("
<< a_typename << ");\n" ;)
fprintf(hf, "Vblockdeclare(%s);\n", (const char*)a_typename);
fflush(hf); // Debug
// Invoke blockimplement macro
DEBUG(cerr << "put to .c file:\n ***Vblockimplement("
<< a_typename << ");\n" ;)
fprintf(cf, "Vblockimplement(%s);\n", (const char*)a_typename);
fflush(cf); // Debug
#endif
}
}
void
#ifdef __GNUG__
blockdef(G2NODE* t, FILE* hf, FILE* cf){
DEBUG(cerr << "put to .c file:\n ***#ifdef __GNUG__\n";)
DEBUG(cerr << "put to .c file:\n ***template class Vblock<"
<< upper(t->name) << ">;\n" ;)
DEBUG(cerr << "put to .c file:\n ***#endif\n";)
fprintf(cf, "#ifdef __GNUG__\n");
fprintf(cf, "template class Vblock<%s>;\n", (const char*)upper(t->name));
fprintf(cf, "#endif\n");
fflush(hf); // Debug
#else
#ifndef _MSC_VER
blockdef(G2NODE*, FILE*, FILE*){
#else
blockdef(G2NODE* t, FILE* hf, FILE* cf){
DEBUG(cerr << "put to .h file:\n ***Vblockdeclare("
<< upper(t->name) << ");\n" ;)
fprintf(hf, "Vblockdeclare(%s);\n", (const char*)upper(t->name));
fflush(hf); // Debug
DEBUG(cerr << "put to .c file:\n ***Vblockimplement("
<< upper(t->name) << ");\n" ;)
fprintf(cf, "Vblockimplement(%s);\n", (const char*)upper(t->name));
fflush(cf); // Debug
#endif
#endif
}
void
generate(G2NODE* t, FILE* hf, FILE* cf){
// Generate typedefs in .h file
// (.c file is needed for constructor definitions, which
// used to be inline in the .h file, but which gave "outline
// inline" warning messages from CC +w
DEBUG(cerr << "ready to call tdef\n";)
bdef(t,hf,cf);
tdef(t,hf,cf);
// Generate descriptor tables in .c file
DEBUG(cerr << "ready to call desc\n";)
desc(t,t->name,cf);
// Generate stream insertion and extraction operators
DEBUG(cerr << "ready to call gen_io\n";)
gen_io(t,hf,cf);
}
void
gen_io(G2NODE* t, FILE* hf, FILE* cf){
// Generate stream insertion and extraction
// function declarations in .h file
fprintf(hf, "\nostream& operator<<(ostream& os, const %s& buf);\n",
(const char*)(upper(t->name)));
fprintf(hf, "istream& operator>>(istream& is, %s& buf);\n\n",
(const char*)(upper(t->name)));
fflush(hf); // Debug
// Generate function definitions in .c file
fprintf(cf, "\nostream& operator<<(ostream& os, const %s& buf){\n",
(const char*)(upper(t->name)));
fprintf(cf,
// " if(!os)return os;\n putrec_ATTLC((void*)&buf,%s,os);\n",
" if(!os)return os;\n putrec_ATTLC((void*)&buf,%s_,os);\n",
(const char*)t->name);
fprintf(cf, " return os;\n}\n");
fprintf(cf, "\nistream& operator>>(istream& is, %s& buf){\n",
(const char*)(upper(t->name)));
// fprintf(cf, " if(!is)return is;\n getrec_ATTLC(&buf,%s,is);\n",
fprintf(cf, " if(!is)return is;\n getrec_ATTLC(&buf,%s_,is);\n",
(const char*)t->name);
fprintf(cf, " return is;\n}\n");
fflush(cf); // Debug
}
void
transform(G2NODE* p){
// static int count=0;
DEBUG(cerr << "enter transform with *p=\n";)
DEBUG(showtree_ATTLC(p,0);)
G2NODE* c=p->child;
if(c){
// Generate a type tag
//
// Note: we just ignore the case where p->val is nonempty
//
// assert(p->val=="");
String rand=ranstr(G2TAGLEN_ATTLC);
SoS[rand] = 1; // record randomly generated class names
p->val=rand;
DEBUG(cerr << "after generating tag, *p=\n";)
DEBUG(showtree_ATTLC(p,0);)
char temp = c->name.char_at(0);
int isarray=(
temp=='*' || // flexible
isdigit_ATTLC(temp) // fixed
);
if(isarray){
DEBUG(cerr << "p is an array\n";)
}else{
DEBUG(cerr << "p is a structure\n";)
}
// Visit p's children
DEBUG(cerr << "ready to visit p's children\n";)
for(G2NODE* cp=c; cp; cp=cp->next){
DEBUG(cerr << "visit next child\n";)
transform(cp);
}
DEBUG(cerr << "after transforming, p=\n";)
DEBUG(showtree_ATTLC(p,0);)
if(isarray){
// Change arrays dimensioned using "*" to "0"
//
// Note: only modify the first character, preserving
// any initial-reserve specification that may follow the
// asterisk, e.g.:
//
// usr
// *(100) LONG # initially reserve 100
if(c->name.char_at(0) == '*'){
c->name[(unsigned)0]='0';
}
// Hoist a type definition for non-terminal arrays
if(c->child!=0){
DEBUG(cerr << "non-terminal array\n";)
DEBUG(cerr << "after hoisting,\n";)
// Set up a new G2NODE for the hoisted type
if(gbuf->ptr >= gbuf->end){
error("out of memory\n");
exit(1);
}
G2NODE* n = gbuf->ptr++;
n->name = c->val;
n->val = "HOISTED"; // jfi
n->next = 0;
n->child = c->child;
// Detach the subtree rooted at p's child
c->child = 0;
DEBUG(cerr << "p=\n";)
DEBUG(showtree_ATTLC(p,0);)
DEBUG(cerr << "n=\n";)
DEBUG(showtree_ATTLC(n,0);)
// Link the subtree into the list of generated type trees
if(tail){
tail->next = n;
tail = n;
}else{
head = tail = n;
}
}
}
// Fix up Strings declared with "*"
}else if(p->val.char_at(0)=='*'){
DEBUG(cerr << "p->val.char_at(0)=='*' means p is a flexible string\n";)
// Again, we only modify the first character, preserving
// any initial-reserve specification that may follow the
// asterisk, e.g.:
//
// usr *(100) # initially reserve 100
p->val[(unsigned)0] = '0';
DEBUG(showtree_ATTLC(p,0);)
// Fix up arrays declared with "*"
}else if(p->name.char_at(0)=='*'){
DEBUG(cerr << "p is a flexible array\n";)
// Again, we only modify the first character, preserving
// any initial-reserve specification that may follow the
// asterisk, e.g.:
//
// usr
// *(100) LONG # initially reserve 100
p->name[(unsigned)0] = '0';
DEBUG(showtree_ATTLC(p,0);)
}
}
void
bolt(const String& stem, FILE* hf, FILE* cf){
// Bolt .h and .c files together with strange symbol
String fastener = "g2" + stem + ranstr(4) + "_ATTLC";
fprintf(hf, "extern int %s;\n", (const char*)fastener);
fflush(hf); // Debug
fprintf(hf, "static int *_%s = &%s;\n\n",
(const char*)fastener,
(const char*)fastener);
fflush(hf); // Debug
fprintf(cf, "int %s;\n", (const char*)fastener);
fflush(hf); // Debug
// The following trick eliminates the warning about the
// unused static int* given by cfront (the inline should
// never be "laid down"
fprintf(hf, "inline void __%s(){ (*_%s)++; }\n",
(const char*)fastener,
(const char*)fastener);
fflush(hf); // Debug
}
void
resettbl(){
DEBUG(cerr << "enter resettbl\n";)
nulldef.name="";
nulldef.val="";
nulldef.next = nulldef.child = 0;
// set up definition for char type
//
// char_def:
//
// tattoo G2MOTHER_ATTLC
// root o--------------> chardef
// base o--------------> chardef
// ptr o--------------> nulldef
// end o-----------|
// buf chardef |
// nulldef |
// xxxxxxx <----------
// xxxxxxx
//
// chardef:
//
// name "CHAR"
// val "-100"
// next o----->
// child o----->
//
DEBUG(cerr << "ready to initialize chardef\n";)
chardef.name="CHAR";
chardef.val=CHAR_ASC_ATTLC;
chardef.next = chardef.child = 0;
DEBUG(shownode_ATTLC(&chardef);)
DEBUG(cerr << "ready to initialize char_def\n";)
char_def.tattoo=G2MOTHER_ATTLC;
char_def.buf.size(2);
char_def.buf[0]=chardef;
char_def.buf[1]=nulldef;
char_def.base=char_def.root=char_def.buf;
#if defined(_MSC_VER) || defined(__TCPLUSPLUS__) || defined(__SUNPRO_CC) || defined(__GNUG__)
char_def.ptr=((G2NODE*)char_def.buf)+1;
char_def.end=((G2NODE*)char_def.buf)+2;
#else
char_def.ptr=char_def.buf+1;
char_def.end=char_def.buf+2;
#endif
DEBUG(showbuf_ATTLC(&char_def);)
// do same for short...
DEBUG(cerr << "ready to initialize shortdef\n";)
shortdef.name="SHORT";
shortdef.val=SHORT_ASC_ATTLC;
shortdef.next = shortdef.child = 0;
DEBUG(shownode_ATTLC(&shortdef);)
DEBUG(cerr << "ready to initialize short_def\n";)
short_def.buf.size(2);
short_def.buf[0]=shortdef;
short_def.buf[1]=nulldef;
short_def.base=short_def.root=short_def.buf;
#if defined(_MSC_VER) || defined(__TCPLUSPLUS__) || defined(__SUNPRO_CC) || defined(__GNUG__)
short_def.ptr=((G2NODE*)short_def.buf)+1;
short_def.end=((G2NODE*)short_def.buf)+2;
#else
short_def.ptr=short_def.buf+1;
short_def.end=short_def.buf+2;
#endif
DEBUG(showbuf_ATTLC(&short_def);)
// ...and long
DEBUG(cerr << "ready to initialize longdef\n";)
longdef.name="LONG";
longdef.val=LONG_ASC_ATTLC;
longdef.next = longdef.child = 0;
DEBUG(shownode_ATTLC(&longdef);)
DEBUG(cerr << "ready to initialize long_def\n";)
long_def.buf.size(2);
long_def.buf[0]=longdef;
long_def.buf[1]=nulldef;
long_def.base=long_def.root=long_def.buf;
#if defined(_MSC_VER) || defined(__TCPLUSPLUS__) || defined(__SUNPRO_CC) || defined(__GNUG__)
long_def.ptr=((G2NODE*)long_def.buf)+1;
long_def.end=((G2NODE*)long_def.buf)+2;
#else
long_def.ptr=long_def.buf+1;
long_def.end=long_def.buf+2;
#endif
DEBUG(showbuf_ATTLC(&long_def);)
// ...and string
DEBUG(cerr << "ready to initialize stringdef\n";)
stringdef.name="STRING";
stringdef.val=STRING_ASC_ATTLC;
stringdef.next = stringdef.child = 0;
DEBUG(shownode_ATTLC(&stringdef);)
DEBUG(cerr << "ready to initialize string_def\n";)
string_def.buf.size(2);
string_def.buf[0]=stringdef;
string_def.buf[1]=nulldef;
string_def.base=string_def.root=string_def.buf;
#if defined(_MSC_VER) || defined(__TCPLUSPLUS__) || defined(__SUNPRO_CC) || defined(__GNUG__)
string_def.ptr=((G2NODE*)string_def.buf)+1;
string_def.end=((G2NODE*)string_def.buf)+2;
#else
string_def.ptr=string_def.buf+1;
string_def.end=string_def.buf+2;
#endif
DEBUG(showbuf_ATTLC(&string_def);)
// reinitialize mtblhead-> list to empty
DEBUG(cerr << "ready to initialize mtblhead-> list to empty\n";)
mtbl* mp = mtblhead;
DEBUG(cerr << "in resettbl, mp = " << long(mp) << "\n";)
while( mp ){
mtbl* t = mp;
mp = mp->next;
delete t;
}
mtblhead = NULL;
// Pre-populate list with definitions for string, long, short,
// and char types
//
// mtbltail
// |
// V
// mtblhead------>o o-------->o o------------>o o
// | | |
// | | |
// V V V
// long_def short_def char_def
//
addtbl(&string_def);
addtbl(&long_def);
addtbl(&short_def);
addtbl(&char_def);
}
////--------------------------------------------
//#include "compfns.h"
mtbl*
addtbl(G2BUF* buf){
// mtbl* mp = (mtbl*)calloc(1,sizeof(mtbl));
mtbl* mp = new mtbl;
mp->buf = 0;
mp->next=0;
if( !mp ){
error("out of memory\n");
exit(1);
}
mp->buf = buf;
if( !mtblhead ){ // first time
mtblhead = mtbltail = mp;
}else{
mtbltail->next = mp;
mtbltail = mp;
}
return mp;
}
void
remtbl(){
mtbl* mp=mtblhead;
mtbl* temp;
mtbltail=0;
// Find the end of the list
while(mp && ((temp=mp->next) != 0)){
mtbltail=mp;
mp=temp;
}
// Remove the last element and fix up pointers
if( mtbltail ){
mtbltail->next=0;
}else{
mtblhead=0;
}
}
#if 0
void
prtbls(const String& stem, FILE* hf, FILE* cf){
int i;
String ustem=upper(stem);
mtbl* mp;
fprintf(hf, "extern G2DESC *%s[];\n", (const char*)stem);
fflush(hf); // Debug
fprintf(hf, "typedef union %s {\n", (const char*)ustem);
fflush(hf); // Debug
for( mp = mtblhead; mp; mp = mp->next ){
String name = mp->buf->root->name;
String uname=upper(name);
if( !isupper(name.char_at(0)) ){
fprintf(hf, " %s %s;\n",
(const char*)uname,
(const char*)name);
fflush(hf); // Debug
}
}
fprintf(hf, "} %s;\n\n", (const char*)ustem);
fflush(hf); // Debug
i = 0;
for( mp = mtblhead; mp; mp = mp->next ){
String name = mp->buf->root->name;
if( !isupper(name.char_at(0)) ){
String uname=upper(name);
fprintf(hf, "#define %s_%s %d\n",
(const char*)ustem,
(const char*)uname,
i++);
fflush(hf); // Debug
}
}
fprintf(cf, "G2DESC *%s[] = {\n", (const char*)stem);
fflush(cf); // Debug
for( mp = mtblhead; mp; mp = mp->next ){
String name = mp->buf->root->name;
if( !isupper(name.char_at(0)) ){
fprintf(cf, " %s,\n", (const char*)name);
fflush(cf); // Debug
}
}
fprintf(cf, " 0\n");
fflush(cf); // Debug
fprintf(cf, "};\n");
fflush(cf); // Debug
fprintf(cf, "int %s_nrec_ = %d;\n\n", (const char*)stem, i);
fflush(cf); // Debug
}
#endif
String
lower(const String& s){
String result(Stringsize(s.length()));
for( int i=0;i<s.length();i++ ){
if( isupper(s.char_at(i)) ){
result += tolower(s.char_at(i));
}else{
result += s.char_at(i);
}
}
return result;
}
String
ranstr(int len){
//#if defined(_MSC_VER) || defined(__TCPLUSPLUS__)
Stringsize sz_tmp(len);
String result(sz_tmp);
//#else
// String result(Stringsize(len));
//#endif
String range = "abcdefghijklmnopqrstuvwxyz"; // used to include caps and digits
int j = range.length();
while( --len >= 0 ){
int i=rand();
int k = i % j;
result+=range.char_at(k);
}
DEBUG(cerr << "ranstr returns result = " << result << "\n";)
return result;
}
ostream& operator<<(ostream& os, const udt_info_ATTLC &) {
return os;
}
unsigned do_checksum(const char *fname) {
unsigned retval = 0;
FILE *f = fopen(fname, "r");
int c;
while ((c = getc(f)) != EOF) {
retval = retval * 271 + c;
}
fclose(f);
return (retval);
}
Forgot your password?
Click here to get the file