Unqualified std::pair breaks builds.
[dyninst.git] / dynC_API / src / dynC.C
1 /*
2  * Copyright (c) 1996-2011 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as "Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * By your use of Paradyn, you understand and agree that we (or any
12  * other person or entity with proprietary rights in Paradyn) are
13  * under no obligation to provide either maintenance services,
14  * update services, notices of latent defects, or correction of
15  * defects for Paradyn.
16  * 
17  * This library is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  * 
22  * This library is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * Lesser General Public License for more details.
26  * 
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30  */
31 //command.C
32 #include "dynC.h"
33 #include "ast.h"
34 #include "snippetGen.h"
35
36 #define BASE_TEN 10
37 extern BPatch_snippet *parse_result;
38
39 extern "C" {
40    void set_lex_input(char *s);
41    int dynCparse();
42 }
43
44 extern char *dynCSnippetName;
45 extern int dyn_debug_ast;
46 extern SnippetGenerator *snippetGen;
47 extern BPatch_point *snippetPoint;
48
49 namespace dynC_API{
50
51    const std::string varNameBase = "dynC_mangled_";
52    const bool debug = false;
53    static int snippetCount = 0;
54
55
56   std::map<BPatch_point *, BPatch_snippet *> *createSnippet(const char *s, std::vector<BPatch_point *> points){
57
58       char *mutS = strdup(s);
59       set_lex_input(mutS);
60
61       std::map<BPatch_point *, BPatch_snippet *> *ret_map = new std::map<BPatch_point *, BPatch_snippet *>();
62       
63       if(ret_map == NULL){
64          fprintf(stderr, "DYNC_INTERNAL Error [%s:%d]: 'new' operation failed!\n", __FILE__, __LINE__);
65          return NULL;
66       }
67
68       snippetCount++;
69
70       std::vector<BPatch_point *>::iterator it;
71       std::stringstream name;
72       name.str() = "";
73       name << "Snippet_" << snippetCount;
74       char *mutName = strdup(name.str().c_str());      
75       dynCSnippetName = mutName;
76
77       for(it = points.begin(); it != points.end(); ++it){
78          snippetPoint = (*it);
79          snippetGen = new SnippetGenerator(**it, mutName);
80
81          if(dynCparse() == 0){
82             ret_map->insert(std::pair<BPatch_point *, BPatch_snippet *>((*it), parse_result));
83          }else{
84             free(mutName);
85             free(mutS);
86             delete ret_map;
87             delete snippetGen;
88             return NULL; //error
89          }
90          delete snippetGen;
91       }
92       free(mutName);
93       return ret_map;
94    }
95
96    BPatch_snippet * createSnippet(const char *s, BPatch_point &point){
97       std::vector<BPatch_point*> points;
98       points.push_back(&point);
99       std::map<BPatch_point *, BPatch_snippet *> *retMap = createSnippet(s, points);
100       if (retMap->empty()){
101          return NULL;
102       }
103       return (*retMap->begin()).second;
104    }
105
106    BPatch_snippet * createSnippet(const char *s, BPatch_addressSpace &addSpace){
107
108       char *mutS = strdup(s);
109       set_lex_input(mutS);
110
111       snippetCount++;
112       std::string name = "Snippet_";
113       name += snippetCount;
114       char *mutName = strdup(name.c_str());      
115       dynCSnippetName = mutName;
116       snippetPoint = NULL;
117       snippetGen = new SnippetGenerator(addSpace, mutName);
118       if(dynCparse() == 0){
119          free(mutS);
120          free(mutName);
121          return parse_result;
122       }
123       free(mutS);
124       free(mutName);
125       return NULL; //error
126    }
127
128    BPatch_snippet * createSnippet(FILE *f, BPatch_point &point){
129       std::string fileString;
130       if(f == NULL){
131          fprintf(stderr, "Error: Unable to open file\n");
132          return NULL;
133       }
134       int c;
135       while((c = fgetc(f)) != EOF)
136       {
137          fileString += (unsigned char)c;
138       }
139       rewind(f);
140
141       char *cstr = strdup(fileString.c_str());
142       BPatch_snippet *retSn = createSnippet(cstr, point);
143       free(cstr);
144       return retSn;
145    }
146
147    std::map<BPatch_point *, BPatch_snippet *> *createSnippet(FILE *f, std::vector<BPatch_point *> points){
148       std::string fileString;
149       if(f == NULL){
150          fprintf(stderr, "Error: Unable to open file\n");
151          return NULL;
152       }
153       int c;
154       while((c = fgetc(f)) != EOF)
155       {
156          fileString += (unsigned char)c;
157       }
158       rewind(f);
159
160       char *cstr = strdup(fileString.c_str());
161       std::map<BPatch_point *, BPatch_snippet *> *retMap = createSnippet(cstr, points);
162       free(cstr);
163       return retMap;
164    }
165
166
167    BPatch_snippet * createSnippet(FILE *f, BPatch_addressSpace &addSpace){
168       std::string fileString;
169       if(f == NULL){
170          fprintf(stderr, "Error: Unable to open file\n");
171          return NULL;
172       }
173       int c;
174       while((c = fgetc(f)) != EOF)
175       {
176          fileString += (unsigned char)c;
177       }
178       rewind(f);
179       char *cstr = strdup(fileString.c_str());
180       BPatch_snippet *retSn = createSnippet(cstr, addSpace);
181       free(cstr);
182       return retSn;
183    }
184
185    BPatch_snippet * createSnippet(std::string str, BPatch_point &point){
186       char *cstr = strdup(str.c_str());
187       BPatch_snippet *retSn = createSnippet(cstr, point);
188       free(cstr);
189       return retSn;
190    }
191
192    std::map<BPatch_point *, BPatch_snippet *> *createSnippet(std::string str, std::vector<BPatch_point *> points){
193       char *cstr = strdup(str.c_str());
194       std::map<BPatch_point *, BPatch_snippet *> *retMap = createSnippet(cstr, points);
195       free(cstr);
196       return retMap;
197    }
198
199
200    BPatch_snippet * createSnippet(std::string str, BPatch_addressSpace &addSpace){
201       char *cstr = strdup(str.c_str());
202       BPatch_snippet *retSn = createSnippet(cstr, addSpace);
203       free(cstr);
204       return retSn;      
205    }
206
207
208    std::string mangle(const char *varName, const char *snippetName, const char *typeName){
209       std::stringstream namestr;
210       namestr << varNameBase << varName << "_" << snippetName;
211       namestr << "_" << typeName;
212       std::string retName = namestr.str();
213       return retName;
214    }
215
216    std::string getMangledStub(const char *varName, const char *snippetName){
217       std::stringstream namestr;
218       namestr << varNameBase << varName << "_" << snippetName;
219       std::string retName = namestr.str();
220       return retName;
221    }
222
223 }