partial void unrecognizedToken(ParadoxParser parser, string token)
{
if (token.Length == 3 && token.ToUpper() == token)
{
_powers.Add(parser.Parse(new TradePower(token)));
}
}
partial void unrecognizedToken(ParadoxParser parser, string token)
{
#if THOROUGH_PARSING
if (parser.ReadBool())
Buildings.Add(token);
#endif
}
public void TokenCallback(ParadoxParser parser, string token)
{
if (token == "setgameplayoptions")
{
options = parser.ReadIntList();
}
}
public void TokenCallback(ParadoxParser parser, string token)
{
Action<ParadoxParser> temp;
if (parseStrategy.TryGetValue(token, out temp))
temp(parser);
else
otherFields.Add(token, parser.ReadString());
}
public void TokenCallback(ParadoxParser parser, string token)
{
Action <ParadoxParser> temp;
if (parseValues.TryGetValue(token, out temp))
{
temp(parser);
}
}
public void NoEmptyStringStatic()
{
var data = "A B C D ".ToStream();
var expected = new[] { "A", "B", "C", "D" };
List <string> actual = new List <string>();
ParadoxParser.Parse(data, (p, s) => actual.Add(s));
Assert.Equal(expected, actual);
}
public void ReadSingleString()
{
var data = "michigan".ToStream();
string actual = string.Empty;
Action <ParadoxParser, string> action = (x, s) => actual = s;
ParadoxParser.Parse(data, action);
Assert.AreEqual("michigan", actual);
}
public void TokenCallback(ParadoxParser parser, string token)
{
if (token == this.currentParsedProvinceStr && parser.CurrentIndent == 0)
{
var newProv = new SaveProvince(this.currentParsedProvince++);
this.Provinces.Add(parser.Parse<SaveProvince>(newProv));
this.currentParsedProvinceStr = this.currentParsedProvince.ToString();
}
}
public void DeserializeStringList()
{
string data = "{me {you them} us} #hehe";
var expected = new List <string> {
"me", "you", "them", "us"
};
var actual = ParadoxParser.Deserialize <List <string> >(data.ToStream());
Assert.Equal(expected, actual);
}
public void DeserializeWithoutInitialCurly()
{
string data = "me=1.000 you=2.500 #hehe";
var expected = new Dictionary <string, double> {
{ "me", 1.000 }, { "you", 2.500 }
};
var actual = ParadoxParser.Deserialize <IDictionary <string, double> >(data.ToStream());
Assert.Equal(expected, actual);
}
public void TokenCallback(ParadoxParser parser, string token)
{
switch (token)
{
case "name": Name = parser.ReadString(); break;
case "leader": Leader = parser.Parse(new ParadoxId()); break;
case "unit": Units.Add(parser.Parse(new Unit())); break;
case "attachments": Attachments = parser.ReadList(() => parser.Parse (new ParadoxId())); break;
}
}
public void TokenCallback(ParadoxParser parser, string token)
{
if (token != "id")
throw new ApplicationException("Unrecognized token: " + token);
if (parser.NextIsBracketed())
EventIds.Add(parser.Parse(new ParadoxId()));
else
EventNames.Add(parser.ReadString());
}
public void ReadSingleSpacedString()
{
var data = " michigan ".ToStream();
string actual = string.Empty;
using (ParadoxParser parser = new ParadoxParser(data))
{
actual = parser.ReadString();
}
Assert.AreEqual("michigan", actual);
}
public static IEnumerable <LandedTitleEntity> ReadAllTitles(string fileName)
{
LandedTitlesFile landedTitlesFile;
using (FileStream fs = new FileStream(fileName, FileMode.Open))
{
landedTitlesFile = ParadoxParser.Parse(fs, new LandedTitlesFile());
}
return(landedTitlesFile.LandedTitles.Select(x => x.Entity));
}
private static IParseTree GetScopeBody(string input)
{
ICharStream cstream = CharStreams.fromstring(input);
ITokenSource lexer = new ParadoxLexer(cstream);
ITokenStream tokens = new CommonTokenStream(lexer);
var parser = new ParadoxParser(tokens);
var data = parser.kvPair().children;
return(data[2].GetChild(1));
}
public void TokenCallback(ParadoxParser parser, string token)
{
if (token == "id")
{
Id = parser.ReadInt32();
}
else if (token == "type")
{
Type = parser.ReadInt32();
}
}
public void TokenCallback(ParadoxParser parser, string token)
{
if (token == Time)
{
var hi = parser.Parse(new holdId());
if (hi.ID != null && hi.ID != string.Empty)
{
HoldID = hi.ID;
}
}
}
public void TokenCallback(ParadoxParser parser, string token)
{
if (parser.CurrentIndent == 1)
{
if (!DiplomaciesByType.ContainsKey(token))
{
DiplomaciesByType.Add(token, new List <Diplomacy>());
}
DiplomaciesByType[token].Add(parser.Parse(new Diplomacy()));
}
}
private ParadoxParser.ParadoxContext GetPlanetParserTree(string planetId)
{
var planetText = planetsData[Convert.ToInt32(planetId)];
ICharStream cstream = CharStreams.fromstring(planetText);
ITokenSource lexer = new ParadoxLexer(cstream);
ITokenStream tokens = new CommonTokenStream(lexer);
var parser = new ParadoxParser(tokens);
var planetData = parser.paradox();
return(planetData);
}
public void EmptyBrackets()
{
var data = @"history=
{
1452.4.9=
{
controller=
{
controller2=""SWE""
}
}
{
}
}
patrol=1";
int? patrol = null;
string controller2 = null;
ParadoxParser.Parse(data.ToStream(), (p, s) =>
{
if (s == "history")
{
p.Parse((p2, s2) =>
{
switch (s2)
{
case "controller2": controller2 = p.ReadString(); break;
case "1452.4.9":
case "controller":
break;
default:
throw new ApplicationException("Unrecognized Token");
}
});
}
else if (s == "patrol")
{
patrol = p.ReadInt32();
}
else
{
throw new ApplicationException("Unrecognized Token");
}
});
Assert.NotNull(patrol);
Assert.Equal(patrol, 1);
Assert.NotNull(controller2);
Assert.Equal(controller2, "SWE");
}
public void TopToken(ParadoxParser parser, string token)
{
if (readMagic)
TokenCallback(parser, token);
else if (!(readMagic = token == "EU4txt"))
{
if (token.StartsWith("EU4bin"))
throw new ApplicationException("Ironman saves are not " +
"supported at this time");
throw new ApplicationException("First token must be EU4txt");
}
}
private static void ParseMiscRules(ParadoxParser parser, string tag)
{
switch (tag)
{
case "liege_culture_chance":
m_ruleset.LiegeCultureChance = parser.ReadInt32();
break;
case "liege_religion_chance":
m_ruleset.LiegeReligionChance = parser.ReadInt32();
break;
case "female_ruler_chance":
m_ruleset.FemaleRulerChance = parser.ReadInt32();
break;
case "ruler_spouse_chance":
m_ruleset.RulerSpouseChance = parser.ReadInt32();
break;
case "reps_force_custom_duchies":
m_ruleset.RepsForceCustomDuchies = parser.ReadBool();
break;
case "rep_expand_chance":
m_ruleset.RepublicExpandChance = parser.ReadInt32();
break;
case "rep_expand_max":
m_ruleset.RepublicExpandMax = parser.ReadInt32();
break;
case "empire_min_size":
m_ruleset.EmpireMinSize = parser.ReadInt32();
break;
case "kingdom_min_size":
m_ruleset.KingdomMinSize = parser.ReadInt32();
break;
case "duchy_min_size":
m_ruleset.DuchyMinSize = parser.ReadInt32();
break;
case "clear_characters":
m_ruleset.ClearCharacters = parser.ReadBool();
break;
case "character_start_id":
m_ruleset.CharacterStartID = parser.ReadInt32();
break;
}
}
public void TokenCallback(ParadoxParser parser, string token)
{
switch (token)
{
case "name": this.name = parser.ReadString(); break;
case "owner": this.owner = parser.ReadString(); break;
case "controller": this.controller = parser.ReadString(); break;
case "culture": this.culture = parser.ReadString(); break;
case "religion": this.religion = parser.ReadString(); break;
case "core": this.cores.Add(parser.ReadString()); break;
}
}
public void TokenCallback(ParadoxParser parser, string token)
{
switch (token)
{
case "actual_added_value": actualAddedValue = parser.ReadInt32(); break;
case "value": value = parser.ReadInt32(); break;
case "from": from = parser.ReadInt32(); break;
case "modifier": modifier = parser.Parse(new Cid()); break;
}
}
public void TokenCallback(ParadoxParser parser, string token)
{
switch (token)
{
case "name": Name = parser.ReadString(); break;
case "leader": Leader = parser.Parse(new ParadoxId()); break;
case "unit": Units.Add(parser.Parse(new Unit())); break;
case "attachments": Attachments = parser.ReadList(() => parser.Parse(new ParadoxId())); break;
}
}
public void ExtraNewLinesDontMatter()
{
var data = "\n\n\n\n ID=100 \n\n\n\n\n\n".ToStream();
int id = 0;
Dictionary <string, Action <ParadoxParser> > dictionary = new Dictionary <string, Action <ParadoxParser> >
{
{ "ID", x => id = x.ReadInt32() }
};
ParadoxParser.Parse(data, dictionary.ParserAdapter());
Assert.AreEqual(100, id);
}
public void TokenCallback(ParadoxParser parser, string token)
{
switch (token)
{
case "name": Name = parser.ReadString(); break;
case "type": Type = parser.ReadString(); break;
case "morale": Morale = parser.ReadDouble(); break;
case "strength": Strength = parser.ReadDouble(); break;
}
}
public void NegativeInt32()
{
var data = "ID=-130".ToStream();
int actual = 0;
Dictionary <string, Action <ParadoxParser> > dictionary = new Dictionary <string, Action <ParadoxParser> >
{
{ "ID", x => actual = x.ReadInt32() }
};
ParadoxParser.Parse(data, dictionary.ParserAdapter());
Assert.AreEqual(-130, actual);
}
public void FirstMilleniumParty()
{
string input = "date=999.1.1";
DateTime expected = new DateTime(999, 1, 1);
DateTime actual = DateTime.MaxValue;
Dictionary <string, Action <ParadoxParser> > dictionary = new Dictionary <string, Action <ParadoxParser> >
{
{ "date", x => actual = x.ReadDateTime() }
};
ParadoxParser.Parse(input.ToStream(), dictionary.ParserAdapter());
Assert.AreEqual(expected, actual);
}
public void WhenChristWasBorn()
{
string input = "date=1.1.1";
DateTime expected = new DateTime(1, 1, 1);
DateTime actual = DateTime.MaxValue;
Dictionary <string, Action <ParadoxParser> > dictionary = new Dictionary <string, Action <ParadoxParser> >
{
{ "date", x => actual = x.ReadDateTime() }
};
ParadoxParser.Parse(input.ToStream(), dictionary.ParserAdapter());
Assert.AreEqual(expected, actual);
}
public void TokenCallback(ParadoxParser parser, string token)
{
Action <ParadoxParser> temp;
if (parseStrategy.TryGetValue(token, out temp))
{
temp(parser);
}
else
{
otherFields.Add(token, parser.ReadString());
}
}
public static IEnumerable <CultureEntity> ReadAllCultures(string fileName)
{
CultureFile cultureFile;
using (FileStream fs = new FileStream(fileName, FileMode.Open))
{
cultureFile = ParadoxParser.Parse(fs, new CultureFile());
}
IEnumerable <CultureGroupEntity> cultureGroups = cultureFile.CultureGroups.Select(x => x.Entity);
return(cultureGroups.SelectMany(x => x.Cultures));
}
public void HourlyDate()
{
string toParse = "date=\"1936.1.10.4\"";
DateTime actual = DateTime.MinValue;
ParadoxParser.Parse(toParse.ToStream(), (p, s) => { if (s == "date")
{
actual = p.ReadDateTime();
}
});
DateTime expected = new DateTime(1936, 1, 10, 4, 0, 0);
Assert.AreEqual(expected, actual);
}
public void SingleBracket()
{
string toParse = "date={date2=\"1770.12.5\"}";
var data = toParse.ToStream();
Dater actual = new Dater();
Dictionary <string, Action <ParadoxParser> > dictionary = new Dictionary <string, Action <ParadoxParser> >
{
{ "date", x => x.Parse(actual) }
};
ParadoxParser.Parse(data, dictionary.ParserAdapter());
Assert.Equal(new DateTime(1770, 12, 5), actual.Date);
}
public void SimpleComment()
{
string toParse = "#culture=michigan";
var data = toParse.ToStream();
string actual = String.Empty;
Dictionary <string, Action <ParadoxParser> > dictionary = new Dictionary <string, Action <ParadoxParser> >
{
{ "culture", x => actual = x.ReadString() }
};
ParadoxParser.Parse(data, dictionary.ParserAdapter());
Assert.AreEqual(String.Empty, actual);
}
public void SimpleWithSpace()
{
var data = "culture = michigan".ToStream();
string actual = String.Empty;
Dictionary <string, Action <ParadoxParser> > dictionary = new Dictionary <string, Action <ParadoxParser> >
{
{ "culture", x => actual = x.ReadString() }
};
ParadoxParser.Parse(data, dictionary.ParserAdapter());
Assert.AreEqual("michigan", actual);
}
private void TestDictionary <K, V>(Stream data, Func <ParadoxParser, IDictionary <K, V> > func, IEnumerable <KeyValuePair <K, V> > expected, string tokenStr)
{
IDictionary <K, V> actual = null;
Action <ParadoxParser, string> action = (p, token) =>
{
if (token == tokenStr)
{
actual = func(p);
}
};
ParadoxParser.Parse(data, action);
Assert.Equal(expected, actual);
}
public void TokenCallback(ParadoxParser parser, string token)
{
switch (token)
{
case "name": Name = parser.ReadString(); break;
case "tax": Tax = parser.ReadDouble(); break;
case "add_core": Cores.Add(parser.ReadString()); break;
case "top_provinces": TopProvinces = parser.ReadStringList(); break;
case "army": Armies.Add(parser.Parse(new Army())); break;
}
}
private void Test <T>(Stream data, Func <ParadoxParser, IEnumerable <T> > func, IEnumerable <T> expected, string tokenStr)
{
IEnumerable <T> actual = null;
Action <ParadoxParser, string> act = (parser, token) =>
{
if (token == tokenStr)
{
actual = func(parser);
}
};
ParadoxParser.Parse(data, act);
Assert.Equal(expected, actual);
}
partial void unrecognizedToken(ParadoxParser parser, string token)
{
if (!parser.NextIsBracketed())
throw new ApplicationException("Unrecognized token: " + token);
WarGoal = parser.Parse(new WarGoal(token));
}
public void TokenCallback(ParadoxParser parser, string token)
{
if (token == "incoming")
incomings.Add(parser.Parse(new Incoming()));
else if (token == "trade_goods_size")
tradeGoodsSize = parser.ReadDoubleList();
else
throw new ApplicationException(token + " not recognized");
}
public void ReadSingleSpacedString()
{
var data = " michigan ".ToStream();
string actual = string.Empty;
using (ParadoxParser parser = new ParadoxParser(data))
{
actual = parser.ReadString();
}
Assert.AreEqual("michigan", actual);
}
private static void ParseRule( ParadoxParser parser, string tag )
{
switch( tag )
{
case "ignored_titles":
m_ruleset.IgnoredTitles.AddRange( parser.ReadStringList() );
break;
case "muslim_laws":
m_ruleset.MuslimLawFollowers.AddRange( parser.ReadStringList() );
break;
case "male_culture":
m_ruleset.MaleCultures.AddRange( parser.ReadStringList() );
break;
case "female_culture":
m_ruleset.FemaleCultures.AddRange( parser.ReadStringList() );
break;
case "male_religion":
m_ruleset.MaleReligions.AddRange( parser.ReadStringList() );
break;
case "female_religion":
m_ruleset.FemaleReligions.AddRange( parser.ReadStringList() );
break;
case "required_rules":
m_ruleset.RequiredRules.AddRange( parser.ReadStringList() );
break;
case "levy_tax_weight":
List<int> ltw = (List<int>)parser.ReadIntList();
if( ltw.Count >= 4 )
{
int i = 0;
m_ruleset.LawRules.LevyTax.Min = ltw[0];
m_ruleset.LawRules.LevyTax.Normal = ltw[1];
m_ruleset.LawRules.LevyTax.Large = ltw[2];
m_ruleset.LawRules.LevyTax.Max = ltw[3];
}
break;
case "character":
m_ruleset.CharRules.Add( ParseCharacter( parser ) );
break;
case "succession_laws":
ParseLaws( parser, m_ruleset.LawRules.SuccessionLaws );
break;
case "gender_laws":
ParseLaws( parser, m_ruleset.LawRules.GenderLaws );
break;
case "misc":
parser.Parse( ParseMiscRules );
break;
case "cul_gen":
parser.Parse( ParseCultureGenRules );
break;
}
}
private static CharacterRule ParseCharacter( ParadoxParser parser )
{
CharacterRule cr = new CharacterRule();
Action<ParadoxParser, string> getOptions = ( p, s ) =>
{
switch( s )
{
case "gender":
cr.IsFemale = p.ReadString() == "female";
break;
case "religion":
cr.Religion = p.ReadString();
break;
case "culture":
cr.Culture = p.ReadString();
break;
case "id":
cr.ID = p.ReadInt32();
break;
case "dynasty":
cr.Dynasty = p.ReadInt32();
break;
case "write_character":
cr.WriteCharacter = p.ReadBool();
break;
case "title":
cr.Titles.Add( p.ReadString() );
break;
}
};
parser.Parse( getOptions );
return cr;
}
public void TokenCallback(ParadoxParser parser, string token)
{
switch (token)
{
case "id": Id = parser.ReadInt32(); break;
case "type": Type = parser.ReadInt32(); break;
}
}
public void TokenCallback(ParadoxParser parser, string token)
{
if (token == "id") Id = parser.ReadInt32();
else if (token == "type") Type = parser.ReadInt32();
}
public void TokenCallback(ParadoxParser parser, string token)
{
switch (token)
{
case "actual_added_value": actualAddedValue = parser.ReadInt32(); break;
case "value": value = parser.ReadInt32(); break;
case "from": from = parser.ReadInt32(); break;
case "modifier": modifier = parser.Parse(new Cid()); break;
}
}
private static void ParseLaws( ParadoxParser parser, List<Law> lawRules )
{
Law l = new Law( "" );
Action<ParadoxParser, string> lawGroup = ( p, s ) =>
{
l = new Law( s );
Action<ParadoxParser, string> lawOptions = ( p2, s2 ) =>
{
switch( s2 )
{
case "banned_religion_group":
case "banned_religion":
l.BannedReligions.Add( p2.ReadString() );
break;
case "allowed_religion_group":
case "allowed_religion":
l.AllowedReligions.Add( p2.ReadString() );
break;
case "banned_culture_group":
case "banned_culture":
l.BannedCultures.Add( p2.ReadString() );
break;
case "allowed_culture_group":
case "allowed_culture":
l.AllowedCultures.Add( p2.ReadString() );
break;
}
};
p.Parse( lawOptions );
lawRules.Add( l );
};
parser.Parse( lawGroup );
}
private static void ParseCultureGenRules( ParadoxParser parser, string tag )
{
switch ( tag )
{
case "dynasty_prefix":
m_ruleset.CulGenDynastyPrefix = parser.ReadInt32();
break;
case "bastard_prefix":
m_ruleset.CulGenBastardPrefix = parser.ReadInt32();
break;
case "patronym_is_prefix":
m_ruleset.CulGenPatronymIsPrefix = parser.ReadInt32();
break;
case "male_patronym":
m_ruleset.CulGenMalePatronym = parser.ReadInt32();
break;
case "female_patronym":
m_ruleset.CulGenFemalePatronym = parser.ReadInt32();
break;
case "ancestor_name":
m_ruleset.CulGenAncestorName = parser.ReadInt32();
break;
case "disinherit_from_blinding":
m_ruleset.CulGenDisinheritFromBlinding = parser.ReadInt32();
break;
case "dukes_called_kings":
m_ruleset.CulGenDukesCalledKings = parser.ReadInt32();
break;
case "founder_names_dynasty":
m_ruleset.CulGenFounderNamesDynasty = parser.ReadInt32();
break;
case "dynasty_title_names":
m_ruleset.CulGenDynastyTitleNames = parser.ReadInt32();
break;
}
}
public void TokenCallback(ParadoxParser parser, string token)
{
switch (token)
{
case "name": Name = parser.ReadString(); break;
case "tax": Tax = parser.ReadDouble(); break;
case "add_core": Cores.Add(parser.ReadString()); break;
case "top_provinces": TopProvinces = parser.ReadStringList(); break;
case "army": Armies.Add(parser.Parse(new Army())); break;
}
}
private static void ParseMiscRules( ParadoxParser parser, string tag )
{
switch ( tag )
{
case "liege_culture_chance":
m_ruleset.LiegeCultureChance = parser.ReadInt32();
break;
case "liege_religion_chance":
m_ruleset.LiegeReligionChance = parser.ReadInt32();
break;
case "female_ruler_chance":
m_ruleset.FemaleRulerChance = parser.ReadInt32();
break;
case "ruler_spouse_chance":
m_ruleset.RulerSpouseChance = parser.ReadInt32();
break;
case "reps_force_custom_duchies":
m_ruleset.RepsForceCustomDuchies = parser.ReadBool();
break;
case "rep_expand_chance":
m_ruleset.RepublicExpandChance = parser.ReadInt32();
break;
case "rep_expand_max":
m_ruleset.RepublicExpandMax = parser.ReadInt32();
break;
case "empire_min_size":
m_ruleset.EmpireMinSize = parser.ReadInt32();
break;
case "kingdom_min_size":
m_ruleset.KingdomMinSize = parser.ReadInt32();
break;
case "duchy_min_size":
m_ruleset.DuchyMinSize = parser.ReadInt32();
break;
case "clear_characters":
m_ruleset.ClearCharacters = parser.ReadBool();
break;
case "character_start_id":
m_ruleset.CharacterStartID = parser.ReadInt32();
break;
}
}
public void TokenCallback(ParadoxParser parser, string token)
{
switch (token)
{
case "name": Name = parser.ReadString(); break;
case "type": Type = parser.ReadString(); break;
case "morale": Morale = parser.ReadDouble(); break;
case "strength": Strength = parser.ReadDouble(); break;
}
}
