public IndexOption(LiteralString comment)
{
KeyBlockSize = null;
IndexType = IndexType.Btree;
ParserName = null;
Comment = comment;
}
public static void Rule(Value lhs, LiteralString literal)
{
Debug.Assert(!string.IsNullOrEmpty(literal.Text));
Debug.Assert(literal.Text.Length >= 2);
var unescapedText = literal.Text;
unescapedText = unescapedText.Substring(1, unescapedText.Length - 2);
unescapedText = unescapedText.Replace(@"""""", @"""");
var codeValueString = new CodeValueString(unescapedText);
lhs.CodeTerm = codeValueString;
}
public void Visit(LiteralString target, Access access)
{
AddSignature(target, access, requiresGeneration: false); // Lexeme is built-in
var expanded = target.Text
.Replace("\\", "\\\\", StringComparison.Ordinal)
.Replace("\r", "\\r", StringComparison.Ordinal)
.Replace("\n", "\\n", StringComparison.Ordinal)
.Replace("\t", "\\t", StringComparison.Ordinal);
Invoker invoker = (i, p, s, f) => $"ParseLexeme({i}, {p}, \"{expanded}\", StringComparison.{target.StringComparison})"; // Invocation
AddInvoker(target, invoker);
}
public override void VisitChildren(AstVisitor visitor)
{
if (HasExpression)
{
Expression.Accept(visitor);
}
LiteralBoolean?.Accept(visitor);
LiteralNumeric?.Accept(visitor);
LiteralString?.Accept(visitor);
VariableReference?.Accept(visitor);
FunctionReference?.Accept(visitor);
FieldReference?.Accept(visitor);
}
public void StringCanBeAssignedFromLiteralString()
{
LiteralString literalString = "foo";
string s = literalString;
Assert.AreEqual(literalString, s);
Assert.IsTrue(s == "foo");
literalString = (string)null;
s = literalString;
Assert.IsTrue(literalString == s);
Assert.IsTrue(s == null);
}
public void LiteralStringCanBeAssignedFromSystemString()
{
LiteralString literalString = "foo";
Assert.AreEqual(literalString, "foo");
Assert.IsTrue(literalString == "foo");
string nullString = null;
literalString = nullString;
Assert.IsTrue(literalString.Equals(nullString)); //! => literalString object itself is not null
Assert.IsTrue(literalString == nullString);
Assert.IsTrue(literalString == null); //! => literalString object itself is not null
}
public static void Rule(Value lhs, LiteralString literal)
{
Debug.Assert(!string.IsNullOrEmpty(literal.Text));
Debug.Assert(literal.Text.Length >= 2);
string unescapedText = literal.Text;
unescapedText = unescapedText.Substring(1, unescapedText.Length - 2);
unescapedText = unescapedText.Replace(@"""""", @"""");
CodeValueString codeValueString = new CodeValueString(unescapedText);
lhs.CodeTerm = codeValueString;
}
/// <returns>upper-case, empty is possible</returns>
public virtual string GetAliasUnescapeUppercase()
{
if (alias == null || alias.Length <= 0)
{
return(alias);
}
if (aliasUpEscape != null)
{
return(aliasUpEscape);
}
switch (alias[0])
{
case '`':
{
return(aliasUpEscape = Identifier.UnescapeName(alias, true));
}
case '\'':
{
return
(aliasUpEscape =
LiteralString.GetUnescapedString(Runtime.Substring(alias, 1, alias.Length - 1), true));
}
case '_':
{
var ind = -1;
for (var i = 1; i < alias.Length; ++i)
{
if (alias[i] == '\'')
{
ind = i;
break;
}
}
if (ind >= 0)
{
var st = new LiteralString(Runtime.Substring(alias, 0, ind),
Runtime.Substring(alias, ind + 1, alias.Length - 1), false);
return(aliasUpEscape = st.GetUnescapedString(true));
}
goto default;
}
default:
{
return(aliasUpEscape = alias.ToUpper());
}
}
}
public String Visit(LiteralString target)
{
var escaped = target.Text
.Replace("\r", "\\r", StringComparison.Ordinal)
.Replace("\n", "\\n", StringComparison.Ordinal)
.Replace("\t", "\\t", StringComparison.Ordinal);
var value = $"\"{escaped}\"";
if (this.ShowHeader)
{
value = $"Lexeme: {value}";
}
return(value);
}
/// <param name="dataType" />
/// <param name="notNull" />
/// <param name="defaultVal">might be null</param>
/// <param name="autoIncrement" />
/// <param name="specialIndex">might be null</param>
/// <param name="comment">might be null</param>
/// <param name="columnFormat">might be null</param>
public ColumnDefinition(DataType dataType,
bool notNull,
IExpression defaultVal,
bool autoIncrement,
SpecialIndex specialIndex,
LiteralString comment,
ColumnFormat columnFormat)
{
if (dataType == null)
{
throw new ArgumentException("data type is null");
}
DataType = dataType;
IsNotNull = notNull;
DefaultVal = defaultVal;
IsAutoIncrement = autoIncrement;
SpecialIndex = specialIndex;
Comment = comment;
ColumnFormat = columnFormat;
}
private void CoreFmt <T0, T1, T2>(ref StringMaker sm, IFormatProvider?provider, T0 arg0, T1 arg1, T2 arg2, ReadOnlySpan <object?> args)
{
var literalIndex = 0;
foreach (var segment in _segments)
{
int literalCount = segment.LiteralCount;
if (literalCount > 0)
{
// the segment has some literal text
sm.Append(LiteralString.AsSpan(literalIndex, literalCount));
literalIndex += literalCount;
}
var argIndex = segment.ArgIndex;
if (argIndex >= 0)
{
// the segment has an arg to format
switch (argIndex)
{
case 0:
AppendArg(ref sm, arg0, segment.ArgFormat, provider, segment.ArgWidth);
break;
case 1:
AppendArg(ref sm, arg1, segment.ArgFormat, provider, segment.ArgWidth);
break;
case 2:
AppendArg(ref sm, arg2, segment.ArgFormat, provider, segment.ArgWidth);
break;
default:
AppendArg(ref sm, args[argIndex - 3], segment.ArgFormat, provider, segment.ArgWidth);
break;
}
}
}
}
public void NullStringBehaviorCheck()
{
Assert.IsTrue(new LiteralString(null) == null); // !!
Assert.IsTrue(new LiteralString(null).ToString() == string.Empty); // !! => ToString() never returns null;
LiteralString s = (string)null;
Assert.IsTrue(s == null);
Assert.IsTrue(s.ToString().Length == 0); //!!
s = null; // instead of (string)null => no implicit cast operator
Assert.IsTrue(s == null);
Exception caught = null;
try{
Assert.IsTrue(s.ToString().Length == 0);
}
catch (NullReferenceException ex) {
caught = ex;
Console.WriteLine(ex.Message);
}
Assert.IsNotNull(caught);
}
/// <summary>
/// Formats a string with arguments.
/// </summary>
/// <param name="destination">Where to write the resulting string.</param>
/// <param name="charsWritten">The number of characters actually written to the destination span.</param>
/// <param name="provider">An optional format provider that provides formatting functionality for individual arguments.</param>
/// <param name="args">Arguments to use in the formatting operation.</param>
/// <returns>True if there was enough room in teh destination span for the resulting string.</returns>
public bool TryFormat(Span <char> destination, out int charsWritten, IFormatProvider?provider, params object?[]?args)
{
CheckNumArgs(0, args);
if (NumArgumentsNeeded == 0)
{
if (destination.Length < LiteralString.Length)
{
charsWritten = 0;
return(false);
}
LiteralString.AsSpan().CopyTo(destination);
charsWritten = LiteralString.Length;
return(true);
}
return(args !.Length switch
{
1 => TryFmt <object?, object?, object?>(destination, out charsWritten, provider, args[0], null, null, null),
2 => TryFmt <object?, object?, object?>(destination, out charsWritten, provider, args[0], args[1], null, null),
3 => TryFmt <object?, object?, object?>(destination, out charsWritten, provider, args[0], args[1], args[2], null),
_ => TryFmt <object?, object?, object?>(destination, out charsWritten, provider, args[0], args[1], args[2], args.AsSpan(3)),
});
public virtual TRes Visit(LiteralString node, TArg arg) => Visit((Expression)node, arg);
private void LoadContentPacks(IEnumerable <RawContentPack> contentPacks)
{
// load content packs
ConfigFileHandler configFileHandler = new ConfigFileHandler(this.ConfigFileName, this.ParseCommaDelimitedField, (pack, label, reason) => this.Monitor.Log($"Ignored {pack.Manifest.Name} > {label}: {reason}", LogLevel.Warn));
foreach (RawContentPack current in contentPacks)
{
this.Monitor.VerboseLog($"Loading content pack '{current.Manifest.Name}'...");
try
{
ContentConfig content = current.Content;
// load tokens
ModTokenContext modContext = this.TokenManager.TrackLocalTokens(current.ManagedPack.Pack);
{
// load config.json
InvariantDictionary <ConfigField> config = configFileHandler.Read(current.ManagedPack, content.ConfigSchema, current.Content.Format);
configFileHandler.Save(current.ManagedPack, config, this.Helper);
if (config.Any())
{
this.Monitor.VerboseLog($" found config.json with {config.Count} fields...");
}
// load config tokens
foreach (KeyValuePair <string, ConfigField> pair in config)
{
ConfigField field = pair.Value;
modContext.Add(new ImmutableToken(pair.Key, field.Value, scope: current.Manifest.UniqueID, allowedValues: field.AllowValues, canHaveMultipleValues: field.AllowMultiple));
}
// load dynamic tokens
foreach (DynamicTokenConfig entry in content.DynamicTokens ?? new DynamicTokenConfig[0])
{
void LogSkip(string reason) => this.Monitor.Log($"Ignored {current.Manifest.Name} > dynamic token '{entry.Name}': {reason}", LogLevel.Warn);
// validate token key
if (string.IsNullOrWhiteSpace(entry.Name))
{
LogSkip("the token name can't be empty.");
continue;
}
if (entry.Name.Contains(InternalConstants.InputArgSeparator))
{
LogSkip($"the token name can't have an input argument ({InternalConstants.InputArgSeparator} character).");
continue;
}
if (Enum.TryParse <ConditionType>(entry.Name, true, out _))
{
LogSkip("the token name is already used by a global token.");
continue;
}
if (config.ContainsKey(entry.Name))
{
LogSkip("the token name is already used by a config token.");
continue;
}
// parse values
ITokenString values;
if (!string.IsNullOrWhiteSpace(entry.Value))
{
if (!this.TryParseStringTokens(entry.Value, modContext, current.Migrator, out string valueError, out values))
{
LogSkip($"the token value is invalid: {valueError}");
continue;
}
}
else
{
values = new LiteralString("");
}
// parse conditions
IList <Condition> conditions;
{
if (!this.TryParseConditions(entry.When, modContext, current.Migrator, out conditions, out string conditionError))
{
this.Monitor.Log($"Ignored {current.Manifest.Name} > '{entry.Name}' token: its {nameof(DynamicTokenConfig.When)} field is invalid: {conditionError}.", LogLevel.Warn);
continue;
}
}
// add token
modContext.Add(new DynamicTokenValue(entry.Name, values, conditions));
}
}
// load patches
IContext patchTokenContext = new SinglePatchContext(current.Manifest.UniqueID, parentContext: modContext); // make patch tokens available to patches
content.Changes = this.SplitPatches(content.Changes).ToArray();
this.NamePatches(current.ManagedPack, content.Changes);
foreach (PatchConfig patch in content.Changes)
{
this.Monitor.VerboseLog($" loading {patch.LogName}...");
this.LoadPatch(current.ManagedPack, patch, patchTokenContext, current.Migrator, logSkip: reasonPhrase => this.Monitor.Log($"Ignored {patch.LogName}: {reasonPhrase}", LogLevel.Warn));
}
}
catch (Exception ex)
{
this.Monitor.Log($"Error loading content pack '{current.Manifest.Name}'. Technical details:\n{ex}", LogLevel.Error);
continue;
}
}
}
public static void LiteralString(StringBuilder o, LiteralString literalString)
{
o.Append("\"");
o.Append(literalString.value);
o.Append("\"");
}
public void Visit(LiteralString node)
{
}
public override BaseType Visit(LiteralString node)
{
return(new StringType());
}
public void Visit(LiteralString target, Signature input)
{
BasicTargetWithInterfaceMethod(target, target.InterfaceMethod, input);
}
public IParseFunction Visit(LiteralString target) => target;
public override string Visit(LiteralString node)
{
return($"\"{node.Value}\"");
}
void DoMyWindow(int windowID)
{
const int kPropertyNameColumnWidth = 150;
const int kValueColumnWidth = 50;
const int kBoxHeight = 100;
const int kBoxWidth = kPropertyNameColumnWidth + kValueColumnWidth + 30;
Environment env = mascaret.getEnvironment();
InstanceSpecification instance = env.getInstance(this.entityName);
Dictionary <string, Slot> ss = instance.Slots;
// Wrap everything in the designated GUI Area
GUILayout.BeginArea(new Rect(15, 17, kBoxWidth, kBoxHeight));
scrollPosition = GUILayout.BeginScrollView(scrollPosition, "", GUILayout.Width(kBoxWidth), GUILayout.Height(kBoxHeight));
GUILayout.BeginVertical();
int xx = 0;
foreach (KeyValuePair <string, Slot> s in ss)
{
string propertyName = s.Value.DefiningProperty.name;
//values[xx] = "";
string type = s.Value.DefiningProperty.Type.name;
PrintSingleton.Instance.log(propertyName + " is " + type);
if (type == "real" || type == "string" || type == "integer" || type == "boolean")
{
if (type == "real")
{
LiteralReal r = (LiteralReal)(s.Value.getValue());
double v = r.RValue;
if (first)
{
values[xx] = v.ToString();
}
}
else if (type == "string")
{
LiteralString st = (LiteralString)(s.Value.getValue());
string v = st.SValue;
if (first)
{
values[xx] = v;
}
}
else if (type == "integer")
{
LiteralInteger i = (LiteralInteger)(s.Value.getValue());
int v = i.IValue;
if (first)
{
values[xx] = v.ToString();
}
}
else if (type == "boolean")
{
LiteralBoolean b = (LiteralBoolean)(s.Value.getValue());
bool v = b.BValue;
if (first)
{
values[xx] = v.ToString();
}
}
GUILayout.BeginHorizontal();
GUILayout.Label(propertyName, GUILayout.Width(kPropertyNameColumnWidth));
values[xx] = GUILayout.TextField(values[xx], 25, GUILayout.Width(kValueColumnWidth));
if (type == "real")
{
s.Value.addValue(new LiteralReal(values[xx]));
}
xx++;
GUILayout.EndHorizontal();
}
}
GUILayout.EndVertical();
GUILayout.EndScrollView();
GUILayout.EndArea();
GUI.DragWindow(new Rect(0, 0, 10000, 10000));
first = false;
}
public virtual T Visit(LiteralString node)
{
return(default(T));
}
/// <summary>Set a local token value.</summary>
/// <param name="name">The token name.</param>
/// <param name="value">The token value.</param>
/// <param name="ready">Whether to mark the token ready.</param>
public void SetLocalValue(string name, string value, bool ready = true)
{
ITokenString str = new LiteralString(value, new LogPathBuilder(nameof(LocalContext), this.Scope, name));
this.SetLocalValue(name, str, ready);
}
public virtual void Visit(LiteralString node)
{
}
