一个c++转c的工具（cfront源码）

/*ident "@(#)cls4:src/template.c 1.30" */ /******************************************************************************* C++ source for the C++ Language System, Release 3.0. This product is a new release of the original cfront developed in the computer science research center of AT&T Bell Laboratories. Copyright (c) 1991 AT&T and UNIX System Laboratories, Inc. Copyright (c) 1984, 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. *******************************************************************************/ /****************************************************************************** * Copyright (c) 1989 by Object Design, Inc., Burlington, Mass. * All rights reserved. *******************************************************************************/ /******************************************************************* * template.c * * TBD * * 1) The template copying process could probably be speeded up * substantially, by only placing "graph-like" nodes in the hash * table. The current implementation plays it safe, and places * all nodes in the hash table. * * 2) remove `$' in lex.c * * 3) Add something to lalex to handle x<y<int>>. Currently parsed * as a right shift rather than nested template instance. *********************************************************************/ #include "tree_copy.h" #include "cfront.h" #include <string.h> #include "template.h" #include <stdlib.h> #include <ctype.h> /* * in string.h on ansi/plan9 * #include <memory.h> */ #include "hash.h" extern int bound; // is not mentioned in the header file bit tempdcl; Ptempl_inst dummyinst=0; Ptempl_inst curr_inst=0; Pfunct_inst fdummyinst=0; Pfunct_inst fcurr_inst=0; static bit notinstflag=0; //static bit matchflag=0; templ_nest check_bound_type = not_set; Ptable bound_expr_tbl; const int max_string_size = 1024; const int default_copy_hash_size = 1000; const int MAX_INST_DEPTH = 8; // maximum instantiations at one time // static data member definitions Pfunt templ_compilation::f_list=0; Pbase_inst basic_inst::head=0; Ptempl templ_compilation::list=0; Pcons templ_compilation::last_cons=0; Pcons templ_compilation::last_friend_cons=0; Pcons templ_compilation::templ_refs=0; Pcons templ_compilation::friend_templ_refs=0; Ptstate templ_compilation::save_templ=0; Ptempl_base templ_compilation::parsed_template=0; Pfunt templ_compilation::f_owner=0; Ptempl templ_compilation::owner=0; Plist templ_compilation::param_end=0; Plist templ_compilation::params=0; // The canonical template compilation instance. templ_compilation *templp; Ptable templ_compilation::templates; Ptype templ_compilation::any_type = ::any_type; // Save and restore global state around a template instantiation void state::save() { Cdcl = ::Cdcl; Cstmt = ::Cstmt; curloc = ::curloc; curr_file = ::curr_file; curr_expr = ::curr_expr; curr_icall = ::curr_icall; curr_loop = ::curr_loop; curr_block = ::curr_block; curr_switch = ::curr_switch; bound = ::bound ; inline_restr = ::inline_restr; last_line = ::last_line; no_of_badcall = ::no_of_badcall; no_of_undcl = ::no_of_undcl; badcall = ::badcall; undcl = ::undcl; } void state::restore() { ::Cdcl = Cdcl; ::Cstmt = Cstmt; ::curloc = curloc; ::curr_file = curr_file; ::curr_expr = curr_expr; ::curr_icall = curr_icall; ::curr_loop = curr_loop; ::curr_block = curr_block; ::curr_switch = curr_switch; ::bound = bound; ::inline_restr = inline_restr; ::last_line = last_line; ::no_of_badcall = no_of_badcall; ::no_of_undcl = no_of_undcl; ::badcall = badcall; ::undcl = undcl; } void state::init() { ::bound = 0; ::inline_restr = 0; ::no_of_badcall = ::no_of_undcl = 0; ::undcl = ::badcall = NULL; // lastline needs to be initialized probaly via a call to putline } bit basetype::parametrized_class() { return ((base == COBJ) && Ptclass(Pbase(this)->b_name->tp)->class_base==UNINSTANTIATED); } bit classdef::parametrized_class() { return (class_base == UNINSTANTIATED); } Templ_type get_class_base(Pbase b) { if (b->base != COBJ) error('i',"::get_class_base: badAT(%k) cobjX",b->base); return Ptclass(Pbase(b)->b_name->tp)->class_base ; } Templ_type get_templ_base(Pbase b) { if (b->base != COBJ) error('i',"::get_templ_base: badAT(%k) cobjX",b->base); return Pclass(Pbase(b)->b_name->tp)->templ_base; } Ptclass get_template_class(Pbase b) { Templ_type t = get_class_base(b) ; if (! ((t==INSTANTIATED) || (t==UNINSTANTIATED))) error ('i', "C is not aYC"); return Ptclass(Pbase(b)->b_name->tp); } Ptempl_inst get_templ_inst(Pbase b) { return (get_template_class(b))->inst; } static bit same_class_templ(Pclass c1, Pclass c2) { // error('d',"same_class_templ: c1 %s c2 %s c1 %d c2 %d", c1->string, c2->string, c1->class_base, c2->class_base); if (c1 == c2) return true; if ((c1->class_base == INSTANTIATED) && (c2->class_base == UNINSTANTIATED) && (Ptclass(c1)->inst->def== Ptclass(c2)->inst->def)) return true; if ((c2->class_base == INSTANTIATED) && (c1->class_base == UNINSTANTIATED) && (Ptclass(c1)->inst->def== Ptclass(c2)->inst->def)) return true; return false; } bit classdef::same_class(Pclass pc,int access) /* Predicate to determine whether two classes are indeed the same. * cfront normally relies on pointer identity, however, this test * is insufficient when parametrized class instantiationa are involved, * since there are potentially many instances of a COBJ and CLASS * for a given instantiation. * * it would seem reasonable to always have the occurrence of * an UNINSTANTIATED and INSTANTIATED instance be checked; * this occurs, for example, in * template<class T> class Tag{}; * template<class T> struct Shrub { * struct Link { Link* next; }; * int advance(Tag<T>&); // UNINSTANTIATED * }; * * void f() { * Shrub<short> s; Tag<short> t; * s.advance(t); } // INSTANTIATED -- same class! * * however, it seems that same_class also determines whether or not * an instantiation needs to be done??? and so currently making this * a blanket check causes certain classes under certain conditions * not to be instantiated -- if this is truly the case, this should * be broken into two functions */ { // error('d',"%t->same_class(%t, %d)",this,pc,access); if (this == 0 || pc == 0 ) return false; if (this == pc) return true; if (class_base == VANILLA && class_base == pc->class_base && in_class && pc->in_class ) { if (in_class == pc->in_class) return true; if (nested_sig && strcmp(nested_sig,pc->nested_sig)==0) return true; return false; } Templ_type this_base = this->class_base; Templ_type pc_base = pc->class_base; if ((this_base == CL_TEMPLATE) && (pc_base == INSTANTIATED) && (Ptclass(pc)->inst->def_basetype()->b_name->tp==this)) return true; // The inverse symmetric test if ((pc_base == CL_TEMPLATE) && (this_base == INSTANTIATED) && (Ptclass(this)->inst->def_basetype()->b_name->tp==pc)) return true; // Check whether the templates were determined to be // identical after instantiation. if ((pc_base == INSTANTIATED) && (this_base == INSTANTIATED) && (strcmp(pc->string,string)==0 || (Ptclass(this)->inst->same(Ptclass(pc)->inst)))) return true; if (access == 0) return false; // change to treatment of friend instantiation // now makes this a possibility if (this_base == INSTANTIATED && pc_base == UNINSTANTIATED) { char *str = Ptclass(this)->inst->def->namep->string; // error('d',"same_class: this: %