/
MemVar.prg
222 lines (173 loc) · 6.73 KB
/
MemVar.prg
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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
//
// Copyright (c) XSharp B.V. All Rights Reserved.
// Licensed under the Apache License, Version 2.0.
// See License.txt in the project root for license information.
//
USING System.Collections.Generic
/// <include file="VoFunctionDocs.xml" path="Runtimefunctions/massign/*" />
/// <include file="RTComments.xml" path="Comments/Memvar/*" />
FUNCTION MAssign(cExp AS STRING,uValue AS USUAL) AS USUAL
RETURN MemVarPutSym(cExp, uValue)
/// <include file="VoFunctionDocs.xml" path="Runtimefunctions/memvarblock/*" />
/// <include file="RTComments.xml" path="Comments/Memvar/*" />
FUNCTION MemVarBlock(cMemvarName AS STRING) AS OBJECT
RETURN {| uValue| IIF (uValue == NIL, MemVarGet(cMemvarName), MemVarPut(cMemvarName, uValue))}
/// <include file="VoFunctionDocs.xml" path="Runtimefunctions/memvarget/*" />
/// <include file="RTComments.xml" path="Comments/Memvar/*" />
FUNCTION MemVarGet(cVarName AS STRING) AS USUAL
RETURN XSharp.MemVar.Get(cVarName)
FUNCTION MemVarTryGet(cVarName AS STRING, uValue OUT USUAL) AS LOGIC
RETURN XSharp.MemVar.TryGet(cVarName, OUT uValue)
/// <include file="VoFunctionDocs.xml" path="Runtimefunctions/memvarput/*" />
/// <include file="RTComments.xml" path="Comments/Memvar/*" />
FUNCTION MemVarPut(cVarName AS STRING,uValue AS USUAL) AS USUAL
RETURN XSharp.MemVar.Put(cVarName, uValue)
/// <summary>
/// Release a memory variable
/// </summary>
/// <param name="symVar">The name of the variable you want to clear. </param>
/// <remarks>
/// The value of this variable will be set to NIL. The variable is NOT deleted.
/// </remarks>
/// <include file="RTComments.xml" path="Comments/Memvar/*" />
FUNCTION MemVarClear(symVar AS STRING) AS VOID
XSharp.MemVar.Put(symVar, NIL)
RETURN
/// <summary>
/// Release a memory variable
/// </summary>
/// <param name="symVar">The name of the variable you want to release. </param>
/// <include file="RTComments.xml" path="Comments/Memvar/*" />
FUNCTION MemVarRelease(symVar AS STRING) AS VOID
XSharp.MemVar.Release(symVar)
RETURN
/// <include file="VoFunctionDocs.xml" path="Runtimefunctions/varget/*" />
/// <include file="RTComments.xml" path="Comments/Memvar/*" />
FUNCTION VarGet(cVarName AS STRING) AS USUAL
RETURN __VarGet(cVarName)
/// <include file="VoFunctionDocs.xml" path="Runtimefunctions/varput/*" />
/// <include file="RTComments.xml" path="Comments/Memvar/*" />
FUNCTION VarPut(cVarName AS STRING,uValue AS USUAL) AS USUAL
RETURN __VarPut(cVarName, uValue)
/// <inheritdoc cref='VarGet' />
/// <param name="symVar">The name of the variable .</param>
FUNCTION VarGetSym(symVar AS SYMBOL) AS USUAL
RETURN __VarGet(symVar)
/// <inheritdoc cref='VarPut' />
/// <param name="symVar">The name of the variable .</param>
FUNCTION VarPutSym(symVar AS SYMBOL,uValue AS USUAL) AS USUAL
RETURN __VarPut(symVar, uValue)
/// <inheritdoc cref='MemVarBlock' />
/// <param name="symVar">The name of the variable .</param>
FUNCTION MemVarBlockSym(symMemvarName AS SYMBOL) AS OBJECT
RETURN {| uValue| IIF (uValue == NIL, MemVarGetSym(symMemvarName), MemVarPutSym(symMemvarName, uValue))}
/// <inheritdoc cref='MemVarGet' />
/// <param name="symVar">The name of the variable .</param>
FUNCTION MemVarGetSym(symVar AS SYMBOL) AS USUAL
RETURN XSharp.MemVar.Get(symVar)
/// <inheritdoc cref='MemVarPut' />
/// <param name="symVar">The name of the variable you want to assign to.</param>
FUNCTION MemVarPutSym(symVar AS SYMBOL, uValue AS USUAL) AS USUAL
RETURN XSharp.MemVar.Put(symVar, uValue)
/// <summary>
/// Clear all memory variables (all public variables and the private variables of the current thread)
/// </summary>
/// <include file="RTComments.xml" path="Comments/Memvar/*" />
FUNCTION _MClear() AS VOID STRICT
XSharp.MemVar.ClearAll()
RETURN
/// <summary>
/// Release one or more memory variables variables.
/// </summary>
/// <param name="var1">Variable 1</param>
/// <param name="var2">Variable 2</param>
/// <param name="var3">Variable 3</param>
/// <param name="var4">Variable 4</param>
/// <param name="varn">Variable n</param>
/// <remarks>
/// The variables are not removed but their values are replaced with NIL.
/// </remarks>
/// <include file="RTComments.xml" path="Comments/Memvar/*" />
FUNCTION _MxRelease (var1, var2, var3, var4, varn) AS VOID CLIPPER
LOCAL nCount AS LONG
LOCAL name AS USUAL
nCount := PCount()
FOR VAR i := 1 TO nCount
name := _GetFParam(i)
IF name:IsString
MemVarRelease(name)
ELSEIF name:IsSymbol
MemVarRelease(name)
ELSE
// throw argument error
NOP
ENDIF
NEXT
RETURN
/// <summary>
/// Release variables that match a certain wildcard pattern
/// </summary>
/// <param name="cMask">The wildcard pattern to use when releasing the memvars. May contain * and ? characters.</param>
/// <param name="lMatch">Indicates if the variables that need to be released should match (TRUE) or NOT match (FALSE) the pattern.</param>
/// <remarks>
/// For most dialects the variables are not removed but their values are replaced with NIL.
/// </remarks>
/// <include file="RTComments.xml" path="Comments/Memvar/*" />
FUNCTION _MRelease(cMask AS STRING, lMatch AS LOGIC) AS VOID
LOCAL cName AS STRING
LOCAL lFoxPro as LOGIC
lFoxPro := XSharp.RuntimeState.Dialect == XSharpDialect.FoxPro
// Case INsensitive comparison. Symbols are all in UPPER case
cMask := Upper(cMask)
cName := _PrivateFirst(TRUE)
DO WHILE cName != NULL
IF _Like(cMask, cName) == lMatch
IF lFoxPro
MemVarRelease(cName)
ELSE
MemVarClear(cName)
ENDIF
ENDIF
cName := _PrivateNext()
ENDDO
RETURN
/// <summary>
/// Enumerate private variables
/// </summary>
FUNCTION _PrivateFirst(lCurrentOnly := FALSE AS LOGIC) AS STRING
RETURN XSharp.MemVar.PrivatesFirst(lCurrentOnly)
/// <summary>
/// Enumerate private variables
/// </summary>
FUNCTION _PrivateNext() AS STRING STRICT
RETURN XSharp.MemVar.PrivatesNext()
/// <summary>
/// Enumerate public variables
/// </summary>
FUNCTION _PublicFirst() AS STRING STRICT
RETURN XSharp.MemVar.PublicsFirst()
/// <summary>
/// Enumerate public variables
/// </summary>
FUNCTION _PublicNext() AS STRING STRICT
RETURN XSharp.MemVar.PublicsNext()
/// <summary>
/// Count private variables
/// </summary>
FUNCTION _PrivateCount(lCurrentOnly := FALSE AS LOGIC) AS INT
RETURN XSharp.MemVar.PrivatesCount(lCurrentOnly)
/// <summary>
/// Count public variables
/// </summary>
FUNCTION _PublicCount() AS INT STRICT
RETURN XSharp.MemVar.PublicsCount()
/// <summary>
/// Enumerate private variables
/// </summary>
FUNCTION _PrivateEnum(lCurrentOnly := FALSE AS LOGIC) AS IEnumerator<STRING>
RETURN XSharp.MemVar.PrivatesEnum(lCurrentOnly)
/// <summary>
/// Enumerate public variables
/// </summary>
FUNCTION _PublicEnum AS IEnumerator<STRING>
RETURN XSharp.MemVar.PublicsEnum()