cpp-dotenv/src/structures/SymbolsTable.cpp at master · adeharo9/cpp-dotenv · GitHub

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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
#include "SymbolsTable.h"


using namespace dotenv;
using namespace std;


SymbolRecord::SymbolRecord(const bool declared,
                           const bool defined,
                           const size_t num_depends,
                           const bool local):
    _declared(declared),
    _defined(defined),
    _local(local),
    _line(0),
    _offset(0),
    _num_depends(num_depends)
{

}


bool SymbolRecord::complete() const
{
    // A complete symbol is a declared, defined and resolved one
    return _declared and _defined and _num_depends == 0;
}


bool SymbolRecord::declared() const
{
    return _declared;
}


bool SymbolRecord::defined() const
{
    return _defined;
}


bool SymbolRecord::resolved() const
{
    // I.e. no dependencies
    return _num_depends == 0;
}


bool SymbolRecord::local() const
{
    return _local;
}


size_t SymbolRecord::line() const
{
    return _line;
}


size_t SymbolRecord::offset() const
{
    return _offset;
}


string& SymbolRecord::value()
{
    return _value;
}


const string& SymbolRecord::value() const
{
    return _value;
}


void SymbolRecord::set_declared()
{
    _declared = true;
}


void SymbolRecord::set_defined()
{
    _defined = true;
}


void SymbolRecord::set_line(const size_t line)
{
    _line = line;
}


void SymbolRecord::set_offset(const size_t offset)
{
    _offset = offset;
}


void SymbolRecord::set_value(const string& value)
{
    // Despite maybe not being resolved, value implies declaration and
    // definition
    if (not _declared)
    {
        _declared = true;
    }

    if (not _defined)
    {
        _defined = true;
    }

    _value = value;
}


void SymbolRecord::dependency_add_one()
{
    ++_num_depends;
}


void SymbolRecord::dependency_resolve_one()
{
    // Make sure to avoid underflow
    if (_num_depends > 0)
    {
        --_num_depends;
    }
}