source: icGREP/icgrep-devel/icgrep/pablo/codegenstate.h @ 4213

Last change on this file since 4213 was 4213, checked in by nmedfort, 5 years ago

Created internal 'string pool' for Call, CharClass?, Var and Assign pablo classes.

File size: 6.1 KB
Line 
1/*
2 *  Copyright (c) 2014 International Characters.
3 *  This software is licensed to the public under the Open Software License 3.0.
4 *  icgrep is a trademark of International Characters.
5 */
6
7#ifndef PS_PABLOS_H
8#define PS_PABLOS_H
9
10#include <pablo/pe_pabloe.h>
11#include <pablo/pe_string.h>
12#include <pablo/pe_advance.h>
13#include <pablo/pe_all.h>
14#include <pablo/pe_and.h>
15#include <pablo/pe_call.h>
16#include <pablo/pe_charclass.h>
17#include <pablo/pe_matchstar.h>
18#include <pablo/pe_not.h>
19#include <pablo/pe_or.h>
20#include <pablo/pe_pabloe.h>
21#include <pablo/pe_scanthru.h>
22#include <pablo/pe_sel.h>
23#include <pablo/pe_var.h>
24#include <pablo/pe_xor.h>
25#include <pablo/ps_assign.h>
26#include <pablo/ps_if.h>
27#include <pablo/ps_while.h>
28#include <unordered_map>
29#include <vector>
30#include <string>
31#include <array>
32#include <pablo/symbol_generator.h>
33
34namespace pablo {
35
36struct CodeGenState {
37
38    CodeGenState(SymbolGenerator & symgen)
39    : mSymbolGenerator(symgen)
40    , mPredecessor(nullptr)
41    , mAll{{makeAll(0), makeAll(1)}}
42    {
43
44    }
45
46    CodeGenState(CodeGenState & cg)
47    : mSymbolGenerator(cg.mSymbolGenerator)
48    , mPredecessor(&cg)
49    , mAll(cg.mAll)    // inherit the original "All" variables for simplicity
50    {
51
52    }
53
54    inline All * createAll(const bool value) const {
55        return mAll[value];
56    }
57
58    Call * createCall(const std::string name);
59
60    Var * createVar(const Assign * assign);
61
62    Var * createVar(const std::string name);
63
64    inline PabloE * createVarIfAssign(PabloE * const input) {
65        return isa<Assign>(input) ? createVar(cast<const Assign>(input)) : input;
66    }
67
68    CharClass * createCharClass(const std::string name);
69    Assign * createAssign(const std::string name, PabloE * expr);
70
71//    PabloE * createAdvance(PabloE * expr);
72//    PabloE * createNot(PabloE * expr);
73//    PabloE * createCall(const std::string name);
74//    PabloE * createVar(const std::string name);
75//    PabloE * createCharClass(const std::string name);
76//    PabloE * createAssign(const std::string name, PabloE * expr);
77//    PabloE * createAnd(PabloE * expr1, PabloE * expr2);
78//    PabloE * createOr(PabloE * expr1, PabloE * expr2);
79//    PabloE * createXor(PabloE * expr1, PabloE * expr2);
80//    PabloE * createMatchStar(PabloE * expr1, PabloE * expr2);
81//    PabloE * createScanThru(PabloE * from, PabloE * thru);
82
83
84
85//    struct ExpressionTable {
86//        inline PabloE * find(PabloE * inst) {
87//            switch(inst->getClassTypeId()) {
88//                // UNARY
89//                case All:       // bool
90//                case Advance:   // pe
91//                case Not:       // pe
92
93//                case Call:      // string
94//                case Var:       // string
95//                case CharClass: // string
96//                // BINARY
97//                case Assign:    // string, pe
98
99//                case And:       // pe, pe
100//                case Or:        // pe, pe
101//                case Xor:       // pe, pe
102//                case MatchStar: // pe, pe
103//                case ScanThru:  // pe, pe
104
105//                case If:        // pe, pe list
106//                case While:     // pe, pe list
107//                // TERNARY
108//                case Sel:       // pe, pe, pe
109//            }
110
111
112//            switch (inst.getNumOperands()) {
113//                case 1: return _unary.find(&inst, inst.getType(), inst.getOperand(0));
114//                case 2: return _binary.find(&inst, inst.getOperand(0), inst.getOperand(1));
115//                case 3: return _ternary.find(&inst, inst.getOperand(0), inst.getOperand(1), inst.getOperand(2));
116//                default: return nullptr;
117//            }
118//        }
119//    private:
120//        template<typename... Args>
121//        struct ExpressionMap {
122//            typedef std::tuple<PabloE::ClassTypeId, Args...> Key;
123//            inline Instruction * find(Instruction * inst, Args... args) {
124//                auto key = std::make_tuple(inst->getOpcode(), args...);
125//                auto itr = _map.find(key);
126//                if (itr == _map.end()) {
127//                    _map.insert(std::make_pair(std::move(key), inst));
128//                    return nullptr;
129//                }
130//                return itr->second;
131//            }
132//        private:
133//            std::unordered_map<Key, PabloE *>                           _map;
134//        };
135//        ExpressionMap<const PabloE *>                                   _unary;
136//        ExpressionMap<const PabloE *, const PabloE *>                   _binary;
137//        ExpressionMap<const PabloE *, const PabloE *, const PabloE *>   _ternary;
138//    };
139
140//    template<typename... Args>
141//    struct ExpressionMap {
142//        typedef std::tuple<PabloE::ClassTypeId, Args...> Key;
143
144//        inline PabloE * find(const PabloE::ClassTypeId type, Args... args) {
145//            auto key = std::make_tuple(type, args...);
146//            auto itr = _map.find(key);
147//            if (itr == _map.end()) {
148//                _map.insert(std::make_pair(std::move(key), inst));
149//                return nullptr;
150//            }
151//            return itr->second;
152//        }
153
154//        inline PabloE * find(const PabloE::ClassTypeId type, Args... args) {
155//            auto key = std::make_tuple(type, args...);
156//            auto itr = _map.find(key);
157//            if (itr == _map.end()) {
158//                _map.insert(std::make_pair(std::move(key), inst));
159//                return nullptr;
160//            }
161//            return itr->second;
162//        }
163
164//    private:
165//        std::unordered_map<Key, PabloE *> _map;
166//    };
167
168
169
170    inline void push_back(PabloE * expr) {
171        mExpressions.push_back(expr);
172    }
173
174    inline std::string symgen(std::string prefix) {
175        return mSymbolGenerator.get(prefix);
176    }
177
178    inline const std::list<PabloE *> & expressions() const {
179        return mExpressions;
180    }
181
182protected:
183
184    String * getString(const std::string string);
185
186private:   
187    SymbolGenerator &                           mSymbolGenerator;
188    CodeGenState * const                        mPredecessor;
189    const std::array<All *, 2>                  mAll;
190    std::unordered_map<std::string, String *>   mStringMap;
191
192
193    std::list<PabloE *>                         mExpressions;
194};
195
196}
197
198#endif // PS_PABLOS_H
Note: See TracBrowser for help on using the repository browser.