blob: c4cb5a504dffd07c190d2ce658ba40136ebe2f9b (
plain)
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
|
/*****
* symbol.h
* Andy Hammerlindl 2002/06/18
*
* Creates symbols from strings so that multiple calls for a symbol of
* the same string will return a pointer to the same object.
*****/
#ifndef SYMBOL_H
#define SYMBOL_H
#include <iostream>
#include <cassert>
#include "common.h"
using std::ostream;
namespace sym {
struct GCInit {
#ifdef _AIX
typedef char * GC_PTR;
#endif
GCInit() {
#ifdef USEGC
GC_set_free_space_divisor(2);
GC_dont_expand=0;
GC_INIT();
#endif
}
};
struct symbol {
static GCInit initialize;
private:
string name;
public:
static mem::map<CONST string,symbol> dict;
static symbol *specialTrans(string s) {
assert(dict.find(s) == dict.end());
return &(dict[s]=symbol(s,true));
}
symbol() : special(false) {}
symbol(string name, bool special=false)
: name(name), special(special) {}
public:
friend class mem::map<CONST string,symbol>;
bool special; // NOTE: make this const (later).
static symbol *initsym;
static symbol *castsym;
static symbol *ecastsym;
static symbol *literalTrans(string s) {
#ifdef SYMACC
symbol &slot = dict[s];
if (slot.name.empty())
slot=symbol(s);
return &slot;
#else
if (dict.find(s) != dict.end())
return &dict[s];
else
return &(dict[s]=symbol(s));
#endif
}
static symbol *opTrans(string s) {
return literalTrans("operator "+s);
}
static symbol *trans(string s) {
// Figure out whether it's an operator or an identifier by looking at the
// first character.
char c=s[0];
return isalpha(c) || c == '_' ? literalTrans(s) : opTrans(s);
}
// Make a symbol that is guaranteed to be unique. It will not match any other
// symbol in the namespace.
static symbol *gensym(string s) {
return new symbol("gensym "+s);
}
operator string () { return string(name); }
friend ostream& operator<< (ostream& out, const symbol& sym)
{ return out << sym.name; }
};
} // namespace sym
#endif
|
