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

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

Removed 'newsym' from CodeGenState? and replaced with an Assign target system in RE_Compiler

File size: 4.6 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_advance.h>
12#include <pablo/pe_all.h>
13#include <pablo/pe_and.h>
14#include <pablo/pe_call.h>
15#include <pablo/pe_charclass.h>
16#include <pablo/pe_matchstar.h>
17#include <pablo/pe_not.h>
18#include <pablo/pe_or.h>
19#include <pablo/pe_pabloe.h>
20#include <pablo/pe_scanthru.h>
21#include <pablo/pe_sel.h>
22#include <pablo/pe_var.h>
23#include <pablo/pe_xor.h>
24#include <pablo/ps_assign.h>
25#include <pablo/ps_if.h>
26#include <pablo/ps_while.h>
27#include <unordered_map>
28#include <vector>
29#include <string>
30#include <array>
31#include <pablo/symbol_generator.h>
32
33namespace pablo {
34
35struct CodeGenState {
36
37    CodeGenState(SymbolGenerator & symgen)
38    : mSymbolGenerator(symgen)
39    , mPredecessor(nullptr)
40    , mAll{{makeAll(0), makeAll(1)}}
41    {
42
43    }
44
45    CodeGenState(CodeGenState & cg)
46    : mSymbolGenerator(cg.mSymbolGenerator)
47    , mPredecessor(&cg)
48    , mAll(cg.mAll)    // inherit the original "All" variables for simplicity
49    {
50
51    }
52
53    inline All * createAll(const bool value) const {
54        return mAll[value];
55    }
56
57//    PabloE * createAdvance(PabloE * expr);
58//    PabloE * createNot(PabloE * expr);
59//    PabloE * createCall(const std::string name);
60//    PabloE * createVar(const std::string name);
61//    PabloE * createCharClass(const std::string name);
62//    PabloE * createAssign(const std::string name, PabloE * expr);
63//    PabloE * createAnd(PabloE * expr1, PabloE * expr2);
64//    PabloE * createOr(PabloE * expr1, PabloE * expr2);
65//    PabloE * createXor(PabloE * expr1, PabloE * expr2);
66//    PabloE * createMatchStar(PabloE * expr1, PabloE * expr2);
67//    PabloE * createScanThru(PabloE * from, PabloE * thru);
68
69
70
71//    struct ExpressionTable {
72//        inline PabloE * find(PabloE * inst) {
73//            switch(inst->getClassTypeId()) {
74//                // UNARY
75//                case All:       // bool
76//                case Advance:   // pe
77//                case Not:       // pe
78
79//                case Call:      // string
80//                case Var:       // string
81//                case CharClass: // string
82//                // BINARY
83//                case Assign:    // string, pe
84
85//                case And:       // pe, pe
86//                case Or:        // pe, pe
87//                case Xor:       // pe, pe
88//                case MatchStar: // pe, pe
89//                case ScanThru:  // pe, pe
90
91//                case If:        // pe, pe list
92//                case While:     // pe, pe list
93//                // TERNARY
94//                case Sel:       // pe, pe, pe
95//            }
96
97
98//            switch (inst.getNumOperands()) {
99//                case 1: return _unary.find(&inst, inst.getType(), inst.getOperand(0));
100//                case 2: return _binary.find(&inst, inst.getOperand(0), inst.getOperand(1));
101//                case 3: return _ternary.find(&inst, inst.getOperand(0), inst.getOperand(1), inst.getOperand(2));
102//                default: return nullptr;
103//            }
104//        }
105//    private:
106//        template<typename... Args>
107//        struct ExpressionMap {
108//            typedef std::tuple<PabloE::ClassTypeId, Args...> Key;
109//            inline Instruction * find(Instruction * inst, Args... args) {
110//                auto key = std::make_tuple(inst->getOpcode(), args...);
111//                auto itr = _map.find(key);
112//                if (itr == _map.end()) {
113//                    _map.insert(std::make_pair(std::move(key), inst));
114//                    return nullptr;
115//                }
116//                return itr->second;
117//            }
118//        private:
119//            std::unordered_map<Key, PabloE *>                           _map;
120//        };
121//        ExpressionMap<const PabloE *>                                   _unary;
122//        ExpressionMap<const PabloE *, const PabloE *>                   _binary;
123//        ExpressionMap<const PabloE *, const PabloE *, const PabloE *>   _ternary;
124//    };
125
126
127    inline void push_back(PabloE * expr) {
128        mExpressions.push_back(expr);
129    }
130
131    inline std::string symgen(std::string prefix) {
132        return mSymbolGenerator.get(prefix);
133    }
134
135    inline const std::list<PabloE *> & expressions() const {
136        return mExpressions;
137    }
138
139private:   
140    SymbolGenerator &               mSymbolGenerator;
141    CodeGenState * const            mPredecessor;
142    const std::array<All *, 2>      mAll;
143
144
145
146    std::list<PabloE *>             mExpressions;
147};
148
149}
150
151#endif // PS_PABLOS_H
Note: See TracBrowser for help on using the repository browser.