SNAP Library 4.0, Developer Reference  2017-07-27 13:18:06
SNAP, a general purpose, high performance system for analysis and manipulation of large networks
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
lx.cpp
Go to the documentation of this file.
1 // Lexical-Chars
3 void TLxChDef::SetUcCh(const TStr& Str){
4  for (int CC=1; CC<Str.Len(); CC++){
5  UcChV[Str[CC]-TCh::Mn]=TCh(Str[0]);}
6 }
7 
8 void TLxChDef::SetChTy(const TLxChTy& ChTy, const TStr& Str){
9  for (int CC=0; CC<Str.Len(); CC++){
10  ChTyV[Str[CC]-TCh::Mn]=TInt(ChTy);}
11 }
12 
14  ChTyV(TCh::Vals), UcChV(TCh::Vals){
15 
16  if (ChDefTy==lcdtUsAscii){
17  // Character-Types
19  SetChTy(lctNum, "0123456789");
20  SetChTy(lctAlpha, "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
21  SetChTy(lctAlpha, "abcdefghijklmnopqrstuvwxyz");
22  SetChTy(lctAlpha, "@_");
23  SetChTy(lctSSym, "\"'.,:;+-*/%!#|&<=>?()[]{}");
27 
28  // Upper-Case
29  for (int Ch=TCh::Mn; Ch<=TCh::Mx; Ch++){UcChV[Ch-TCh::Mn]=TCh(char(Ch));}
30  SetUcCh("Aa"); SetUcCh("Bb"); SetUcCh("Cc"); SetUcCh("Dd"); SetUcCh("Ee");
31  SetUcCh("Ff"); SetUcCh("Gg"); SetUcCh("Hh"); SetUcCh("Ii"); SetUcCh("Jj");
32  SetUcCh("Kk"); SetUcCh("Ll"); SetUcCh("Mm"); SetUcCh("Nn"); SetUcCh("Oo");
33  SetUcCh("Pp"); SetUcCh("Qq"); SetUcCh("Rr"); SetUcCh("Ss"); SetUcCh("Tt");
34  SetUcCh("Uu"); SetUcCh("Vv"); SetUcCh("Ww"); SetUcCh("Xx"); SetUcCh("Yy");
35  SetUcCh("Zz");
36  } else
37  if (ChDefTy==lcdtYuAscii){
38  // Character-Types
40  SetChTy(lctNum, "0123456789");
41  SetChTy(lctAlpha, "ABC^]D\\EFGHIJKLMNOPQRS[TUVWXYZ@");
42  SetChTy(lctAlpha, "abc~}d|efghijklmnopqrs{tuvwxyz`");
43  SetChTy(lctAlpha, "_");
44  SetChTy(lctSSym, "\".,:;+-*/%!#&<=>?()");
48 
49  // Upper-Case
50  for (int Ch=TCh::Mn; Ch<=TCh::Mx; Ch++){UcChV[Ch-TCh::Mn]=TCh(char(Ch));}
51  SetUcCh("Aa"); SetUcCh("Bb"); SetUcCh("Cc"); SetUcCh("^~"); SetUcCh("]}");
52  SetUcCh("Dd"); SetUcCh("\\|"); SetUcCh("Ee"); SetUcCh("Ff"); SetUcCh("Gg");
53  SetUcCh("Hh"); SetUcCh("Ii"); SetUcCh("Jj"); SetUcCh("Kk"); SetUcCh("Ll");
54  SetUcCh("Mm"); SetUcCh("Nn"); SetUcCh("Oo"); SetUcCh("Pp"); SetUcCh("Qq");
55  SetUcCh("Rr"); SetUcCh("Ss"); SetUcCh("[{"); SetUcCh("Tt"); SetUcCh("Uu");
56  SetUcCh("Vv"); SetUcCh("Ww"); SetUcCh("Xx"); SetUcCh("Yy"); SetUcCh("Zz");
57  SetUcCh("@`");
58  } else {
59  Fail;
60  }
61 }
62 
63 bool TLxChDef::IsNmStr(const TStr& Str) const {
64  if (Str.Len()==0){return false;}
65  if (!IsAlpha(Str.GetCh(0))){return false;}
66  for (int ChN=1; ChN<Str.Len(); ChN++){
67  if (!IsAlNum(Str.GetCh(ChN))){return false;}}
68  return true;
69 }
70 
71 TStr TLxChDef::GetUcStr(const TStr& Str) const {
72  TChA UcStr;
73  for (int ChN=0; ChN<Str.Len(); ChN++){
74  UcStr.AddCh(GetUc(Str.GetCh(ChN)));}
75  return UcStr;
76 }
77 
78 
80  static PLxChDef UsAsciiChDef=NULL;
81  static PLxChDef YuAsciiChDef=NULL;
82  switch (ChDefTy){
83  case lcdtUsAscii:
84  if (UsAsciiChDef.Empty()){UsAsciiChDef=TLxChDef::New(lcdtUsAscii);}
85  return UsAsciiChDef;
86  case lcdtYuAscii:
87  if (YuAsciiChDef.Empty()){YuAsciiChDef=TLxChDef::New(lcdtYuAscii);}
88  return YuAsciiChDef;
89  default: Fail; return NULL;
90  }
91 }
92 
93 //TLxChDef& TLxChDef::GetChDefRef(const TLxChDefTy& ChDefTy){
94 // switch (ChDefTy){
95 // case lcdtUsAscii: return *UsAsciiChDef;
96 // case lcdtYuAscii: return *YuAsciiChDef;
97 // default: Fail; return *UsAsciiChDef;;
98 // }
99 //}
100 
102 // Lexical-Symbols
103 const TStr TLxSymStr::UndefStr="<undefined>";
104 const TStr TLxSymStr::LnStr="<line>";
105 const TStr TLxSymStr::TabStr="<tab>";
106 const TStr TLxSymStr::IntStr="<integer>";
107 const TStr TLxSymStr::FltStr="<float>";
108 const TStr TLxSymStr::StrStr="<string>";
109 const TStr TLxSymStr::IdStrStr="<id-string>";
110 const TStr TLxSymStr::QStrStr="<q-string>";
111 const TStr TLxSymStr::PeriodStr=".";
112 const TStr TLxSymStr::DPeriodStr="..";
113 const TStr TLxSymStr::CommaStr=",";
114 const TStr TLxSymStr::ColonStr=":";
115 const TStr TLxSymStr::DColonStr="::";
116 const TStr TLxSymStr::SemicolonStr=";";
117 const TStr TLxSymStr::PlusStr="+";
118 const TStr TLxSymStr::MinusStr="-";
119 const TStr TLxSymStr::AsteriskStr="*";
120 const TStr TLxSymStr::SlashStr="/";
121 const TStr TLxSymStr::PercentStr="%";
123 const TStr TLxSymStr::VBarStr="|";
124 const TStr TLxSymStr::AmpersandStr="&";
125 const TStr TLxSymStr::QuestionStr="?";
126 const TStr TLxSymStr::HashStr="#";
127 const TStr TLxSymStr::EqStr="=";
128 const TStr TLxSymStr::NEqStr="<>";
129 const TStr TLxSymStr::LssStr="<";
130 const TStr TLxSymStr::GtrStr=">";
131 const TStr TLxSymStr::LEqStr="<=";
132 const TStr TLxSymStr::GEqStr=">=";
133 const TStr TLxSymStr::LParenStr="(";
134 const TStr TLxSymStr::RParenStr=")";
135 const TStr TLxSymStr::LBracketStr="[";
136 const TStr TLxSymStr::RBracketStr="]";
137 const TStr TLxSymStr::LBraceStr="{";
138 const TStr TLxSymStr::RBraceStr="}";
139 const TStr TLxSymStr::EolnStr="<end-of-line>";
140 const TStr TLxSymStr::EofStr="<end-of-file>";
141 
143  switch (Sym){
144  case syUndef: return UndefStr;
145  case syLn: return LnStr;
146  case syTab: return TabStr;
147  case syInt: return IntStr;
148  case syFlt: return FltStr;
149  case syStr: return StrStr;
150  case syIdStr: return IdStrStr;
151  case syQStr: return QStrStr;
152  case syPeriod: return PeriodStr;
153  case syDPeriod: return DPeriodStr;
154  case syComma: return CommaStr;
155  case syColon: return ColonStr;
156  case syDColon: return DColonStr;
157  case sySemicolon: return SemicolonStr;
158  case syPlus: return PlusStr;
159  case syMinus: return MinusStr;
160  case syAsterisk: return AsteriskStr;
161  case sySlash: return SlashStr;
162  case syPercent: return PercentStr;
163  case syExclamation: return ExclamationStr;
164  case syVBar: return VBarStr;
165  case syAmpersand: return AmpersandStr;
166  case syQuestion: return QuestionStr;
167  case syHash: return HashStr;
168  case syEq: return EqStr;
169  case syNEq: return NEqStr;
170  case syLss: return LssStr;
171  case syGtr: return GtrStr;
172  case syLEq: return LEqStr;
173  case syGEq: return GEqStr;
174  case syLParen: return LParenStr;
175  case syRParen: return RParenStr;
176  case syLBracket: return LBracketStr;
177  case syRBracket: return RBracketStr;
178  case syLBrace: return LBraceStr;
179  case syRBrace: return RBraceStr;
180  case syEoln: return EolnStr;
181  case syEof: return EofStr;
182  default: Fail; return TStr();
183  }
184 }
185 
187  static TStrIntH StrToLxSymH(100);
188  if (StrToLxSymH.Len()==0){
189  StrToLxSymH.AddDat(PeriodStr, syPeriod);
190  StrToLxSymH.AddDat(DPeriodStr, syDPeriod);
191  StrToLxSymH.AddDat(CommaStr, syComma);
192  StrToLxSymH.AddDat(ColonStr, syColon);
193  StrToLxSymH.AddDat(DColonStr, syDColon);
194  StrToLxSymH.AddDat(SemicolonStr, sySemicolon);
195  StrToLxSymH.AddDat(PlusStr, syPlus);
196  StrToLxSymH.AddDat(MinusStr, syMinus);
197  StrToLxSymH.AddDat(AsteriskStr, syAsterisk);
198  StrToLxSymH.AddDat(SlashStr, sySlash);
199  StrToLxSymH.AddDat(PercentStr, syPercent);
200  StrToLxSymH.AddDat(ExclamationStr, syExclamation);
201  StrToLxSymH.AddDat(VBarStr, syVBar);
202  StrToLxSymH.AddDat(AmpersandStr, syAmpersand);
203  StrToLxSymH.AddDat(QuestionStr, syQuestion);
204  StrToLxSymH.AddDat(HashStr, syHash);
205  StrToLxSymH.AddDat(EqStr, syEq);
206  StrToLxSymH.AddDat(NEqStr, syNEq);
207  StrToLxSymH.AddDat(LssStr, syLss);
208  StrToLxSymH.AddDat(GtrStr, syGtr);
209  StrToLxSymH.AddDat(LEqStr, syLEq);
210  StrToLxSymH.AddDat(GEqStr, syGEq);
211  StrToLxSymH.AddDat(LParenStr, syLParen);
212  StrToLxSymH.AddDat(RParenStr, syRParen);
213  StrToLxSymH.AddDat(LBracketStr, syLBracket);
214  StrToLxSymH.AddDat(RBracketStr, syRBracket);
215  StrToLxSymH.AddDat(LBraceStr, syLBrace);
216  StrToLxSymH.AddDat(RBraceStr, syRBrace);
217  }
218  int KeyId=StrToLxSymH.GetKeyId(Str);
219  if (KeyId==-1){
220  return syUndef;
221  } else {
222  return TLxSym(int(StrToLxSymH[KeyId]));
223  }
224 }
225 
226 bool TLxSymStr::IsSep(const TLxSym& PrevSym, const TLxSym& Sym){
227  static TFSet SepPrevSymSet=TFSet()|
230  syEoln|syEof;
231 
232  static TFSet SepSymSet=TFSet()|
234  syEq|
237  syEoln|syEof;
238 
239  return !SepPrevSymSet.In(PrevSym) && !SepSymSet.In(Sym);
240 }
241 
243 // Lexical-Symbol-State
245  Sym(syUndef),
246  Str(), UcStr(), CmtStr(),
247  Bool(false), Int(0), Flt(0),
248  SymLnN(-1), SymLnChN(-1), SymChN(-1){}
249 
251  Sym(SymSt.Sym),
252  Str(SymSt.Str), UcStr(SymSt.UcStr), CmtStr(SymSt.CmtStr),
253  Bool(SymSt.Bool), Int(SymSt.Int), Flt(SymSt.Flt),
254  SymLnN(SymSt.SymLnN), SymLnChN(SymSt.SymLnChN), SymChN(SymSt.SymChN){Fail;}
255 
257  Sym(Lx.Sym),
258  Str(Lx.Str), UcStr(Lx.UcStr), CmtStr(Lx.CmtStr),
259  Bool(Lx.Bool), Int(Lx.Int), Flt(Lx.Flt),
260  SymLnN(Lx.SymLnN), SymLnChN(Lx.SymLnChN), SymChN(Lx.SymChN){}
261 
263  Lx.Sym=Sym;
264  Lx.Str=Str; Lx.UcStr=UcStr; Lx.CmtStr=CmtStr;
265  Lx.Bool=Bool; Lx.Int=Int; Lx.Flt=Flt;
267 
269 // Lexical-Input
270 TILx::TILx(const PSIn& _SIn, const TFSet& OptSet, const TLxChDefTy& ChDefTy):
271  ChDef(TLxChDef::GetChDef(ChDefTy)),
272  SIn(_SIn), RSIn(*SIn),
273  PrevCh(' '), Ch(' '), LnN(0), LnChN(0-1), ChN(0-1),
274  PrevSymStStack(), RwStrH(50),
275  IsCmtAlw(false), IsRetEoln(false), IsSigNum(false),
276  IsUniStr(false), IsCsSens(false), IsExcept(false),
277  IsTabSep(false), IsList(false),
278  Sym(syUndef),
279  Str(), UcStr(), CmtStr(),
280  Bool(false), Int(0), Flt(0),
281  SymLnN(-1), SymLnChN(-1), SymChN(-1){
282  for (int Opt=0; Opt<iloMx; Opt++){
283  if (OptSet.In(Opt)){SetOpt(Opt, true);}}
284 }
285 
286 void TILx::SetOpt(const int& Opt, const bool& Val){
287  switch (Opt){
288  case iloCmtAlw: IsCmtAlw=Val; break;
289  case iloRetEoln: IsRetEoln=Val; break;
290  case iloSigNum: IsSigNum=Val; break;
291  case iloUniStr: IsUniStr=Val; break;
292  case iloCsSens: IsCsSens=Val; break;
293  case iloExcept: IsExcept=Val; break;
294  case iloTabSep: IsTabSep=Val; break;
295  case iloList: IsList=Val; break;
296  default: Fail;
297  }
298 }
299 
300 TLxSym TILx::AddRw(const TStr& Str){
302  TStr UcStr=ChDef->GetUcStr(Str);
303  IAssert(!RwStrH.IsKey(UcStr));
304  TLxSym RwSym=TLxSym(syMnRw+RwStrH.Len());
305  RwStrH.AddDat(Str, TInt(int(RwSym)));
306  return RwSym;
307 }
308 
309 PSIn TILx::GetSIn(const char& SepCh){
311  while ((Ch!=TCh::EofCh)&&(Ch!=SepCh)){GetCh();}
312  return SIn;
313 }
314 
315 TLxSym TILx::GetSym(const TFSet& Expect){
316  CmtStr.Clr();
317  if (!PrevSymStStack.Empty()){
318  // symbols already on the stack
320  } else
321  if (Expect.In(syLn)){
322  // symbol is the whole line string
323  if (Ch==TCh::EofCh){
324  Sym=syEof;
325  } else {
326  Str.Clr();
327  if (IsBof()){GetCh();}
328  while (!ChDef->IsTerm(Ch)){Str.AddCh(Ch); GetCh();}
329  bool _IsRetEoln=IsRetEoln; IsRetEoln=true;
331  IsRetEoln=_IsRetEoln;
332  }
333  } else
334  if (IsTabSep){
335  // symbol is between tab characters
336  if (IsBof()){GetCh();}
337  if (Ch==TCh::TabCh){ // tab character
338  Sym=syTab; GetCh();
339  } else
340  if (ChDef->IsTerm(Ch)){ // eoln & eof characters
341  bool _IsRetEoln=IsRetEoln; IsRetEoln=true; IsTabSep=false;
343  IsRetEoln=_IsRetEoln; IsTabSep=true;
344  } else {
345  Str.Clr();
346  while ((!ChDef->IsTerm(Ch))&&(Ch!=TCh::TabCh)){
347  Str.AddCh(Ch); UcStr.AddCh(ChDef->GetUc(Ch)); GetCh();}
348  Sym=syStr; QuoteP=false;
349  }
350  } else {
351  // usual symbol
352  while (ChDef->IsSpace(Ch)){GetCh();}
354 
355  if (ChDef->IsAlpha(Ch)){
356  if (IsUniStr){Sym=syStr;} else {Sym=syIdStr;}
357  Str.Clr(); UcStr.Clr(); QuoteP=false;
358  do {Str.AddCh(Ch); UcStr.AddCh(ChDef->GetUc(Ch));}
359  while (ChDef->IsAlNum(GetCh()));
360  if (!RwStrH.Empty()){
361  TStr RwStr=Str; if (!IsCsSens){RwStr=UcStr;}
362  int SymKeyId=RwStrH.GetKeyId(RwStr);
363  if (SymKeyId!=-1){Sym=TLxSym(int(RwStrH[SymKeyId]));}
364  }
365  if (Expect.In(syBool)){
368  }
369  } else
370  if ((Ch=='"')||(Ch=='\'')){
371  if (IsUniStr){Sym=syStr;} else {Sym=syQStr;}
372  Str.Clr(); UcStr.Clr(); QuoteP=true; QuoteCh=Ch;
373  GetCh();
374  forever{
375  while ((Ch!=QuoteCh)&&(Ch!='\\')&&(Ch!=TCh::EofCh)){
376  Str.AddCh(Ch); UcStr.AddCh(ChDef->GetUc(Ch)); GetCh();}
377  if (Ch==TCh::EofCh){
378  Sym=syUndef; break;
379  } else if (Ch==QuoteCh){
380  GetCh(); break;
381  } else {
382  GetCh();
383  switch (Ch){
384  case '"': Str.AddCh(Ch); UcStr.AddCh(ChDef->GetUc(Ch)); GetCh(); break;
385  case '\\': Str.AddCh(Ch); UcStr.AddCh(ChDef->GetUc(Ch)); GetCh(); break;
386  case '\'': Str.AddCh(Ch); UcStr.AddCh(ChDef->GetUc(Ch)); GetCh(); break;
387  case '/': Str.AddCh(Ch); UcStr.AddCh(ChDef->GetUc(Ch)); GetCh(); break;
388  case 'b': Str.AddCh('\b'); UcStr.AddCh(ChDef->GetUc(Ch)); GetCh(); break;
389  case 'f': Str.AddCh('\f'); UcStr.AddCh(ChDef->GetUc(Ch)); GetCh(); break;
390  case 'n': Str.AddCh('\n'); UcStr.AddCh(ChDef->GetUc(Ch)); GetCh(); break;
391  case 'r': Str.AddCh('\r'); UcStr.AddCh(ChDef->GetUc(Ch)); GetCh(); break;
392  case 't': Str.AddCh('\t'); UcStr.AddCh(ChDef->GetUc(Ch)); GetCh(); break;
393  case 'u': {
394  // unicode character, represented using 4 hexadecimal digits
395  GetCh(); EAssertR(TCh::IsHex(Ch), "Invalid hexadecimal digit in unicode escape");
396  int UChCd = TCh::GetHex(Ch);
397  GetCh(); EAssertR(TCh::IsHex(Ch), "Invalid hexadecimal digit in unicode escape");
398  UChCd = 16 * UChCd + TCh::GetHex(Ch);
399  GetCh(); EAssertR(TCh::IsHex(Ch), "Invalid hexadecimal digit in unicode escape");
400  UChCd = 16 * UChCd + TCh::GetHex(Ch);
401  GetCh(); EAssertR(TCh::IsHex(Ch), "Invalid hexadecimal digit in unicode escape");
402  UChCd = 16 * UChCd + TCh::GetHex(Ch);
403  // get as UTF8 encoded characters
404  TUnicode::EncodeUtf8(UChCd, Str);
405  TUnicode::EncodeUtf8(UChCd, UcStr); }
406  GetCh(); break;
407  default: Sym=syUndef; break;
408  }
409  if (Sym==syUndef){
410  throw PExcept(new TExcept("Invalid Escape Sequence in Quoted String"));}
411  }
412  }
413  } else
414  if ((ChDef->IsNum(Ch))||(IsSigNum&&((Ch=='+')||(Ch=='-')))){
415  Str.Clr(); bool IntP=true;
416  do {Str.AddCh(Ch);} while (ChDef->IsNum(GetCh()));
417  if (Expect.In(syFlt)){
418  if (Ch=='.'){
419  Str.AddCh(Ch); IntP=false;
420  while (ChDef->IsNum(GetCh())){Str.AddCh(Ch);}
421  }
422  if ((Ch=='e')||(Ch=='E')){
423  Str.AddCh(Ch); GetCh(); IntP=false;
424  if ((Ch=='+')||(Ch=='-')){Str.AddCh(Ch); GetCh();}
425  while (ChDef->IsNum(Ch)){Str.AddCh(Ch); GetCh();}
426  }
427  }
428  UcStr=Str;
429  if (IntP&&(Expect.In(syInt))){
430  Sym=syInt; Int=atoi(Str.CStr());
431  } else {
432  Sym=syFlt; Flt=atof(Str.CStr());
433  }
434  } else
435  if ((Ch==TCh::CrCh)||(Ch==TCh::LfCh)){
436  Sym=syEoln;
437  if (Ch==TCh::CrCh){if (GetCh()==TCh::LfCh){GetCh();}} else
438  if (Ch==TCh::LfCh){if (GetCh()==TCh::CrCh){GetCh();}}
439  LnN++; LnChN=0; if (!IsRetEoln){GetSym(Expect);}
440  } else
441  if (Ch=='/'){
442  GetCh();
443  if ((IsCmtAlw)&&(Ch=='/')){
444  TChA _CmtStr;
445  do {_CmtStr+=GetCh();} while (!ChDef->IsTerm(Ch));
446  _CmtStr.Pop(); _CmtStr.Trunc();
447  if (Ch==TCh::CrCh){
448  if (GetCh()==TCh::LfCh){GetCh();}
449  } else
450  if (Ch==TCh::LfCh){
451  if (GetCh()==TCh::CrCh){GetCh();}
452  }
453  if (IsRetEoln){Sym=syEoln;} else {GetSym(Expect);}
454  CmtStr=_CmtStr;
455  } else
456  if (Ch=='*'){
457  TChA _CmtStr;
458  do {
459  while (GetCh()!='*'){_CmtStr+=Ch;}
460  _CmtStr+=GetCh();
461  } while (Ch!='/');
462  _CmtStr.Pop(); _CmtStr.Pop(); _CmtStr.Trunc();
463  GetCh(); GetSym(Expect);
464  CmtStr=_CmtStr;
465  } else {
466  Sym=sySlash;
467  }
468  } else
469  if (Ch==TCh::EofCh){
470  Sym=syEof;
471  } else {
472  switch (Ch){
473  case '.':
474  if (GetCh()=='.'){Sym=syDPeriod; GetCh();}
475  else {Sym=syPeriod;} break;
476  case ',': Sym=syComma; GetCh(); break;
477  case ':':
478  if (GetCh()==':'){Sym=syDColon; GetCh();}
479  else {Sym=syColon;} break;
480  case ';': Sym=sySemicolon; GetCh(); break;
481  case '+': Sym=syPlus; GetCh(); break;
482  case '-': Sym=syMinus; GetCh(); break;
483  case '*': Sym=syAsterisk; GetCh(); break;
484  case '/': Sym=sySlash; GetCh(); break;
485  case '%': Sym=syPercent; GetCh(); break;
486  case '!': Sym=syExclamation; GetCh(); break;
487  case '|': Sym=syVBar; GetCh(); break;
488  case '&': Sym=syAmpersand; GetCh(); break;
489  case '=': Sym=syEq; GetCh(); break;
490  case '<':
491  GetCh();
492  if (Ch=='='){Sym=syLEq; GetCh();}
493  else if (Ch=='>'){Sym=syNEq; GetCh();}
494  else {Sym=syLss;} break;
495  case '>':
496  if (GetCh()=='='){Sym=syGEq; GetCh();}
497  else {Sym=syGtr;} break;
498  case '?': Sym=syQuestion; GetCh(); break;
499  case '#':
500  if (IsCmtAlw){
501  TChA _CmtStr;
502  do {_CmtStr+=GetCh();} while (!ChDef->IsTerm(Ch));
503  _CmtStr.Pop(); _CmtStr.Trunc();
504  if (Ch==TCh::CrCh){
505  if (GetCh()==TCh::LfCh){GetCh();}
506  } else
507  if (Ch==TCh::LfCh){
508  if (GetCh()==TCh::CrCh){GetCh();}
509  }
510  if (IsRetEoln){Sym=syEoln;} else {GetSym(Expect);}
511  CmtStr=_CmtStr;
512  } else {
513  Sym=syHash; GetCh();
514  }
515  break;
516  case '(': Sym=syLParen; GetCh(); break;
517  case ')': Sym=syRParen; GetCh(); break;
518  case '[': Sym=syLBracket; GetCh(); break;
519  case ']': Sym=syRBracket; GetCh(); break;
520  case '{': Sym=syLBrace; GetCh(); break;
521  case '}': Sym=syRBrace; GetCh(); break;
522  default: Sym=syUndef; GetCh(); break;
523  }
524  }
525  }
526 
527  if ((!Expect.In(Sym))&&(!Expect.Empty())){
528  if (IsExcept){
529  TStr MsgStr=
530  TStr("Unexpected symbol (")+GetSymStr()+") ["+GetFPosStr()+"]";
531  throw PExcept(new TExcept(MsgStr));
532  } else {
533  Fail;
534  }
535  }
536  return Sym;
537 }
538 
539 TStr TILx::GetStrToCh(const char& ToCh){
540  Sym=syStr; Str.Clr(); UcStr.Clr();
541  while ((Ch!=ToCh)&&(Ch!=TCh::EofCh)){
542  Str.AddCh(Ch); UcStr.AddCh(ChDef->GetUc(Ch)); GetCh();}
543  return Str;
544 }
545 
546 TStr TILx::GetStrToEolnOrCh(const char& ToCh){
547  Sym=syStr; Str.Clr(); UcStr.Clr();
548  while ((Ch!=ToCh)&&(Ch!=TCh::CrCh)&&(Ch!=TCh::LfCh)&&(Ch!=TCh::EofCh)){
549  Str.AddCh(Ch); UcStr.AddCh(ChDef->GetUc(Ch)); GetCh();}
550  return Str;
551 }
552 
553 TStr TILx::GetStrToEoln(const bool& DoTrunc){
554  Sym=syStr; Str.Clr(); UcStr.Clr();
555  while ((Ch!=TCh::CrCh)&&(Ch!=TCh::LfCh)&&(Ch!=TCh::EofCh)){
556  Str.AddCh(Ch); UcStr.AddCh(ChDef->GetUc(Ch)); GetCh();}
557  if (DoTrunc){Str.ToTrunc(); UcStr.ToTrunc();}
558  return Str;
559 }
560 
561 TStr TILx::GetStrToEolnAndCh(const char& ToCh){
562  Sym=syStr; Str.Clr(); UcStr.Clr();
563  if (IsBof()){GetCh();}
564  forever {
565  if (Ch==TCh::EofCh){break;}
566  if (((ChN==0)||(PrevCh==TCh::CrCh)||(PrevCh==TCh::LfCh))&&(Ch==ToCh)){
567  GetCh(); break;}
568  else {Str.AddCh(Ch); UcStr.AddCh(ChDef->GetUc(Ch)); GetCh();}
569  }
570  return Str;
571 }
572 
574  while ((Ch!=TCh::CrCh)&&(Ch!=TCh::LfCh)&&(Ch!=TCh::EofCh)){
575  GetCh();}
576  if (Ch==TCh::CrCh){if (GetCh()==TCh::LfCh){GetCh();}} else
577  if (Ch==TCh::LfCh){if (GetCh()==TCh::CrCh){GetCh();}}
578 }
579 
580 TLxSym TILx::PeekSym(const int& Syms){
581  TILxSymSt CurSymSt(*this);
582  TSStack<TILxSymSt> SymStStack;
583  for (int SymN=0; SymN<Syms; SymN++){
584  GetSym(); SymStStack.Push(TILxSymSt(*this));}
585  TLxSym PeekedSym=Sym;
586  while (!SymStStack.Empty()){
587  SymStStack.Top().Restore(*this); SymStStack.Pop();
588  PutSym();
589  }
590  CurSymSt.Restore(*this);
591  return PeekedSym;
592 }
593 
595  switch (Sym){
596  case syInt: return Str;
597  case syFlt: return Str;
598  case syStr: return Str;
599  case syIdStr: return Str;
600  case syQStr: return Str;
601  default:
602  if ((syMnRw<=Sym)&&(Sym<=syMxRw)){return Str;}
603  else {return TLxSymStr::GetSymStr(Sym);}
604  }
605 }
606 
608  TChA ChA;
609  ChA+="File:"; ChA+=SIn->GetSNm();
610  ChA+=" Line:"; ChA+=TInt::GetStr(LnN+1);
611  ChA+=" Char:"; ChA+=TInt::GetStr(LnChN);
612  return ChA;
613 }
614 
615 TStr TILx::GetQStr(const TStr& Str, const bool& QuoteP, const char& QuoteCh){
616  if (QuoteP){
617  TChA ChA;
618  ChA+=QuoteCh;
619  int StrLen=Str.Len();
620  for (int ChN=0; ChN<StrLen; ChN++){
621  char Ch=Str.CStr()[ChN];
622  if (Ch==QuoteCh){ChA+=QuoteCh; ChA+=QuoteCh;}
623  else {ChA+=Ch;}
624  }
625  ChA+=QuoteCh;
626  return ChA;
627  } else {
628  return Str;
629  }
630 }
631 
632 void TILx::GetVarBoolV(const TStr& VarNm, TBoolV& BoolV, const bool& NewLn){
633  BoolV.Clr();
634  GetVar(VarNm, true, NewLn);
635  while (GetSym(syRBracket, syBool)==syQStr){
636  BoolV.Add(Bool); if (NewLn){GetEoln();}}
637  if (NewLn){GetEoln();}
638 }
639 
640 void TILx::GetVarIntV(const TStr& VarNm, TIntV& IntV, const bool& NewLn){
641  IntV.Clr();
642  GetVar(VarNm, true, NewLn);
643  while (GetSym(syRBracket, syInt)==syInt){
644  IntV.Add(Int); if (NewLn){GetEoln();}}
645  if (NewLn){GetEoln();}
646 }
647 
648 void TILx::GetVarFltV(const TStr& VarNm, TFltV& FltV, const bool& NewLn){
649  FltV.Clr();
650  GetVar(VarNm, true, NewLn);
651  while (GetSym(syRBracket, syFlt)==syFlt){
652  FltV.Add(Flt); if (NewLn){GetEoln();}}
653  if (NewLn){GetEoln();}
654 }
655 
656 void TILx::GetVarStrV(const TStr& VarNm, TStrV& StrV, const bool& NewLn){
657  StrV.Clr();
658  GetVar(VarNm, true, NewLn);
659  while (GetSym(syRBracket, syQStr)==syQStr){
660  StrV.Add(Str); if (NewLn){GetEoln();}}
661  if (NewLn){GetEoln();}
662 }
663 
664 void TILx::GetVarStrPrV(const TStr& VarNm, TStrPrV& StrPrV, const bool& NewLn){
665  StrPrV.Clr();
666  GetVar(VarNm, true, NewLn);
668  TStr Str1=GetQStr(); TStr Str2=GetQStr();
670  StrPrV.Add(TStrPr(Str1, Str2)); if (NewLn){GetEoln();}
671  }
672  if (NewLn){GetEoln();}
673 }
674 
675 void TILx::GetVarStrVV(const TStr& VarNm, TVec<TStrV>& StrVV, const bool& NewLn){
676  StrVV.Clr();
677  GetVar(VarNm, true, NewLn);
679  StrVV.Add();
680  while (GetSym(syQStr, syRBracket)==syQStr){
681  StrVV.Last().Add(Str);}
682  if (NewLn){GetEoln();}
683  }
684  if (NewLn){GetEoln();}
685 }
686 
687 void TILx::GetLnV(const TStr& FNm, TStrV& LnV){
688  TFIn SIn(FNm); LnV.Clr(); TChA Ln;
689  if (!SIn.Eof()){
690  char Ch=SIn.GetCh();
691  while (!SIn.Eof()){
692  if ((Ch==TCh::CrCh)||(Ch==TCh::LfCh)){
693  if (!SIn.Eof()){
694  char PrevCh=Ch; Ch=SIn.GetCh();
695  if (!SIn.Eof()){
696  if (PrevCh==TCh::CrCh){if (Ch==TCh::LfCh){Ch=SIn.GetCh();}} else
697  if (PrevCh==TCh::LfCh){if (Ch==TCh::CrCh){Ch=SIn.GetCh();}}
698  }
699  }
700  LnV.Add(Ln); Ln.Clr();
701  } else {
702  Ln+=Ch; Ch=SIn.GetCh();
703  }
704  }
705  if (!Ln.Empty()){
706  LnV.Add(Ln);}
707  }
708 }
709 
711 // Lexical-Output
712 void TOLx::PutSep(const TLxSym& Sym){
713  if (TLxSymStr::IsSep(PrevSym, Sym)){
714  if (IsTabSep){RSOut.PutCh(TCh::TabCh);} else {RSOut.PutCh(' ');}}
715  PrevSym=Sym;
716 }
717 
718 TOLx::TOLx(const PSOut& _SOut, const TFSet& OptSet, const TLxChDefTy& ChDefTy):
719  ChDef(TLxChDef::GetChDef(ChDefTy)), SOut(_SOut), RSOut(*SOut),
720  IsCmtAlw(false), IsFrcEoln(false), IsSigNum(false),
721  IsUniStr(false), IsCsSens(false), IsTabSep(false), IsVarIndent(false),
722  VarIndentLev(0),
723  RwStrH(50), RwSymH(50), PrevSym(syUndef){
724  for (int Opt=0; Opt<oloMx; Opt++){
725  if (OptSet.In(Opt)){SetOpt(Opt, true);}}
726 }
727 
728 void TOLx::SetOpt(const int& Opt, const bool& Val){
729  switch (Opt){
730  case oloCmtAlw: IsCmtAlw=Val; break;
731  case oloFrcEoln: IsFrcEoln=Val; break;
732  case oloSigNum: IsSigNum=Val; break;
733  case oloUniStr: IsUniStr=Val; break;
734  case oloCsSens: IsCsSens=Val; break;
735  case oloTabSep: IsTabSep=Val; break;
736  case oloVarIndent: IsVarIndent=Val; break;
737  default: Fail;
738  }
739 }
740 
741 TLxSym TOLx::AddRw(const TStr& Str){
743  TStr UcStr=ChDef->GetUcStr(Str);
744  IAssert(!RwStrH.IsKey(UcStr));
745  TLxSym RwSym=TLxSym(syMnRw+RwStrH.Len());
746  RwStrH.AddDat(Str, TInt(int(RwSym)));
747  RwSymH.AddDat(TInt(int(RwSym)), Str);
748  return RwSym;
749 }
750 
751 void TOLx::PutSym(const TLxSym& Sym){
752  TStr Str;
753  if ((syMnRw<=Sym)&&(Sym<=syMxRw)){
754  Str=Str=RwSymH[Sym];
755  } else {
756  Str=TLxSymStr::GetSymStr(Sym);
757  }
758  PutSep(Sym); RSOut.PutStr(Str);
759 }
760 
761 void TOLx::PutVarBoolV(const TStr& VarNm, const TBoolV& BoolV,
762  const bool& NewLn, const bool& CheckIdStr){
763  PutVar(VarNm, true, NewLn, CheckIdStr);
764  for (int BoolN=0; BoolN<BoolV.Len(); BoolN++){
766  PutBool(BoolV[BoolN]);
767  if (NewLn){PutLn();}
768  }
769  PutVarEnd(true, NewLn);
770 }
771 
772 void TOLx::PutVarIntV(const TStr& VarNm, const TIntV& IntV,
773  const bool& NewLn, const bool& CheckIdStr){
774  PutVar(VarNm, true, NewLn, CheckIdStr);
775  for (int IntN=0; IntN<IntV.Len(); IntN++){
777  PutInt(IntV[IntN]);
778  if (NewLn){PutLn();}
779  }
780  PutVarEnd(true, NewLn);
781 }
782 
783 void TOLx::PutVarFltV(const TStr& VarNm, const TFltV& FltV,
784  const bool& NewLn, const bool& CheckIdStr){
785  PutVar(VarNm, true, NewLn, CheckIdStr);
786  for (int FltN=0; FltN<FltV.Len(); FltN++){
788  PutFlt(FltV[FltN]);
789  if (NewLn){PutLn();}
790  }
791  PutVarEnd(true, NewLn);
792 }
793 
794 void TOLx::PutVarStrV(const TStr& VarNm, const TStrV& StrV,
795  const bool& NewLn, const bool& CheckIdStr){
796  PutVar(VarNm, true, NewLn, CheckIdStr);
797  for (int StrN=0; StrN<StrV.Len(); StrN++){
799  PutQStr(StrV[StrN]);
800  if (NewLn){PutLn();}
801  }
802  PutVarEnd(true, NewLn);
803 }
804 
805 void TOLx::PutVarStrPrV(const TStr& VarNm, const TStrPrV& StrPrV,
806  const bool& NewLn, const bool& CheckIdStr){
807  PutVar(VarNm, true, NewLn, CheckIdStr);
808  for (int StrPrN=0; StrPrN<StrPrV.Len(); StrPrN++){
811  PutQStr(StrPrV[StrPrN].Val1); PutQStr(StrPrV[StrPrN].Val2);
813  if (NewLn){PutLn();}
814  }
815  PutVarEnd(true, NewLn);
816 }
817 
818 void TOLx::PutVarStrVV(const TStr& VarNm, const TVec<TStrV>& StrVV,
819  const bool& NewLn, const bool& CheckIdStr){
820  PutVar(VarNm, true, NewLn, CheckIdStr);
821  for (int StrVN=0; StrVN<StrVV.Len(); StrVN++){
824  for (int StrN=0; StrN<StrVV[StrVN].Len(); StrN++){
825  PutQStr(StrVV[StrVN][StrN]);}
827  if (NewLn){PutLn();}
828  }
829  PutVarEnd(true, NewLn);
830 }
831 
833 // Preprocessor
835  Assert(Ch!=TCh::EofCh);
836  PrevCh=Ch;
837  Ch=((SIn->Eof()) ? TCh::EofCh : SIn->GetCh());
838  //putchar(Ch);
839  return Ch;
840 }
841 
842 bool TPreproc::IsSubstId(const TStr& SubstId, TStr& SubstValStr) const {
843  if (SubstIdToKeyIdValPrVH.IsKey(SubstId)){
844  const TStrPrV& KeyIdValPrV=SubstIdToKeyIdValPrVH.GetDat(SubstId);
845  for (int KeyN=0; KeyN<KeyIdValPrV.Len(); KeyN++){
846  if (SubstKeyIdV.IsIn(KeyIdValPrV[KeyN].Val1)){
847  SubstValStr=KeyIdValPrV[KeyN].Val2;
848  return true;
849  }
850  }
851  return false;
852  } else {
853  return false;
854  }
855 }
856 
857 TPreproc::TPreproc(const TStr& InFNm, const TStr& OutFNm,
858  const TStr& SubstFNm, const TStrV& _SubstKeyIdV):
859  SIn(), SubstKeyIdV(_SubstKeyIdV),
860  PrevCh('\0'), Ch('\0'){
861  // load substitution file
862  if (!SubstFNm.Empty()){
863  PXmlDoc XmlDoc=TXmlDoc::LoadTxt(SubstFNm);
864  // get list of substitutions
865  TXmlTokV SubstTokV; XmlDoc->GetTok()->GetTagTokV("Subst", SubstTokV);
866  for (int SubstTokN=0; SubstTokN<SubstTokV.Len(); SubstTokN++){
867  PXmlTok SubstTok=SubstTokV[SubstTokN];
868  // get substitution-id
869  TStr SubstId=SubstTok->GetArgVal("Id", "");
870  if (!SubstId.Empty()){
871  // create substitution
872  TStrPrV& KeyIdValPrV=SubstIdToKeyIdValPrVH.AddDat(SubstId);
873  // get list of substitution-strings
874  TXmlTokV StrTokV; SubstTok->GetTagTokV("Str", StrTokV);
875  for (int StrTokN=0; StrTokN<StrTokV.Len(); StrTokN++){
876  PXmlTok StrTok=StrTokV[StrTokN];
877  // get key-value pair
878  TStr KeyId=StrTok->GetArgVal("Key", "");
879  TStr ValStr=StrTok->GetTokStr(false);
880  // assign key-value-pair
881  if (!KeyId.Empty()){
882  KeyIdValPrV.Add(TStrPr(KeyId, ValStr));
883  }
884  }
885  }
886  }
887  }
888  // substitution
889  // open files
890  SIn=TFIn::New(InFNm);
891  PSOut SOut=TFOut::New(OutFNm);
892  // set copy & ignore mode
893  bool CopyModeP=false; bool IgnoreModeP=false;
894  GetCh();
895  while (Ch!=TCh::EofCh){
896  if (isalpha(Ch)||(((PrevCh=='\0')||(PrevCh=='\r')||(PrevCh=='\n'))&&(Ch=='#'))){
897  // collect identifier
898  TChA IdChA;
899  do {
900  IdChA+=Ch; GetCh();
901  } while ((Ch!=TCh::EofCh)&&(isalnum(Ch)));
902  // check identifier
903  if (IdChA=="#ifdef"){
904  // collect condition-key-id
905  TChA CondKeyIdChA;
906  while ((Ch!=TCh::EofCh)&&(Ch!='\n')&&(Ch!='\r')){
907  CondKeyIdChA+=Ch; GetCh();}
908  // skip eoln
909  if (Ch=='\n'){GetCh(); if (Ch=='\r'){GetCh();}}
910  else if (Ch=='\r'){GetCh(); if (Ch=='\n'){GetCh();}}
911  // check for key
912  CondKeyIdChA.Trunc();
913  IAssert(CopyModeP==false);
914  IAssert(IgnoreModeP==false);
915  if (SubstKeyIdV.IsIn(CondKeyIdChA)){
916  CopyModeP=true; IgnoreModeP=false;
917  } else {
918  CopyModeP=false; IgnoreModeP=true;
919  }
920  } else
921  if (IdChA=="#endif"){
922  // move to eoln
923  while ((Ch!=TCh::EofCh)&&(Ch!='\n')&&(Ch!='\r')){
924  GetCh();}
925  // skip eoln
926  if (Ch=='\n'){GetCh(); if (Ch=='\r'){GetCh();}}
927  else if (Ch=='\r'){GetCh(); if (Ch=='\n'){GetCh();}}
928  // reset copy&ignore modes
929  IAssert(CopyModeP||IgnoreModeP);
930  CopyModeP=false; IgnoreModeP=false;
931  } else {
932  // substitution or add id-as-seen
933  TStr SubstValStr;
934  if ((!CopyModeP)&&(IsSubstId(IdChA, SubstValStr))){
935  if (!IgnoreModeP){SOut->PutStr(SubstValStr);}
936  } else {
937  if (!IgnoreModeP){SOut->PutStr(IdChA);}
938  }
939  }
940  } else {
941  // single character
942  if (!IgnoreModeP){SOut->PutCh(Ch);}
943  GetCh();
944  }
945  }
946 }
947 
#define IAssert(Cond)
Definition: bd.h:262
static bool IsHex(const char &Ch)
Definition: dt.h:1067
char Ch
Definition: lx.h:134
void PutLn(const int &IndentLev=0)
Definition: lx.h:302
TLxChDef(const TLxChDefTy &ChDefTy)
Definition: lx.cpp:13
Definition: lx.h:248
Definition: lx.h:49
Definition: lx.h:49
Definition: lx.h:127
Definition: lx.h:50
bool IsTabSep
Definition: lx.h:257
Definition: lx.h:6
bool Empty()
Definition: ds.h:2590
bool IsCsSens
Definition: lx.h:138
int SymLnN
Definition: lx.h:152
static const TStr QuestionStr
Definition: lx.h:81
TStr GetStr() const
Definition: dt.h:1197
TILx(const PSIn &_SIn, const TFSet &OptSet=TFSet(), const TLxChDefTy &ChDefTy=lcdtUsAscii)
Definition: lx.cpp:270
static PSOut New(const TStr &FNm, const bool &Append=false)
Definition: fl.cpp:442
int Len() const
Definition: dt.h:487
Definition: lx.h:53
bool IsAlNum(const char &Ch) const
Definition: lx.h:30
static PLxChDef New(const TLxChDefTy &ChDefTy=lcdtUsAscii)
Definition: lx.h:16
bool IsSubstId(const TStr &SubstId, TStr &SubstValStr) const
Definition: lx.cpp:842
void GetVarIntV(const TStr &VarNm, TIntV &IntV, const bool &NewLn=true)
Definition: lx.cpp:640
void PutVarStrPrV(const TStr &VarNm, const TStrPrV &StrPrV, const bool &NewLn=true, const bool &CheckIdStr=true)
Definition: lx.cpp:805
Definition: lx.h:45
char PrevCh
Definition: lx.h:364
TStr GetStrToEoln(const bool &DoTrunc=false)
Definition: lx.cpp:553
TPt< TExcept > PExcept
Definition: bd.h:198
TPair< TStr, TStr > TStrPr
Definition: ds.h:107
TLxChTy
Definition: lx.h:5
virtual int PutCh(const char &Ch)=0
void GetEoln()
Definition: lx.h:189
static const TStr CommaStr
Definition: lx.h:69
void PutVar(const TStr &VarNm, const bool &LBracket=false, const bool &NewLn=false, const bool &CheckIdStr=true)
Definition: lx.h:309
Definition: lx.h:50
Definition: lx.h:5
void PutSym()
Definition: lx.h:199
Definition: lx.h:49
Definition: lx.h:45
TStr GetSymStr() const
Definition: lx.cpp:594
bool IsIn(const TVal &Val) const
Checks whether element Val is a member of the vector.
Definition: ds.h:828
bool IsUniStr
Definition: lx.h:256
bool Empty() const
Definition: bits.h:145
#define forever
Definition: bd.h:6
void PutBool(const TBool &Bool)
Definition: lx.h:275
TStrIntH RwStrH
Definition: lx.h:137
Definition: lx.h:48
static const TStr DPeriodStr
Definition: lx.h:68
TVal & Top()
Definition: ds.h:2594
Definition: lx.h:46
void SkipToEoln()
Definition: lx.cpp:573
int Int
Definition: lx.h:111
bool Empty() const
Definition: dt.h:260
bool IsTabSep
Definition: lx.h:139
#define Fail
Definition: bd.h:238
bool IsSpace(const char &Ch) const
Definition: lx.h:27
bool Empty() const
Definition: bd.h:501
static const TStr EofStr
Definition: lx.h:96
static const TStr ColonStr
Definition: lx.h:70
TStrV SubstKeyIdV
Definition: lx.h:363
bool IsList
Definition: lx.h:139
TLxSym
Definition: lx.h:44
void Clr()
Definition: dt.h:258
Definition: lx.h:45
void AddCh(const char &Ch, const int &MxLen=-1)
Definition: dt.h:271
bool IsAlpha(const char &Ch) const
Definition: lx.h:28
Definition: lx.h:48
Definition: bits.h:119
Definition: lx.h:47
Definition: lx.h:5
TSizeTy Len() const
Returns the number of elements in the vector.
Definition: ds.h:575
int VarIndentLev
Definition: lx.h:258
TStr GetStrToEolnOrCh(const char &ToCh)
Definition: lx.cpp:546
void PutInt(const TInt &Int)
Definition: lx.h:277
bool Empty() const
Definition: hash.h:227
void GetVarStrV(const TStr &VarNm, TStrV &StrV, const bool &NewLn=true)
Definition: lx.cpp:656
Definition: lx.h:51
static int GetHex(const char &Ch)
Definition: dt.h:1069
void PutVarBoolV(const TStr &VarNm, const TBoolV &BoolV, const bool &NewLn=true, const bool &CheckIdStr=true)
Definition: lx.cpp:761
Definition: lx.h:45
int ChN
Definition: lx.h:135
void GetVar(const TStr &VarNm, const bool &LBracket=false, const bool &NewLn=false)
Definition: lx.h:209
Definition: lx.h:52
Definition: lx.h:45
PLxChDef ChDef
Definition: lx.h:253
bool IsRetEoln
Definition: lx.h:138
void PutSep(const TLxSym &Sym)
Definition: lx.cpp:712
void Restore(TILx &Lx)
Definition: lx.cpp:262
void GetVarFltV(const TStr &VarNm, TFltV &FltV, const bool &NewLn=true)
Definition: lx.cpp:648
void PutSym(const TLxSym &Sym)
Definition: lx.cpp:751
Definition: lx.h:5
TLxSym AddRw(const TStr &Str)
Definition: lx.cpp:741
void PutQStr(const TStr &Str)
Definition: lx.h:289
Definition: lx.h:47
bool QuoteP
Definition: lx.h:153
Definition: lx.h:126
void SetOpt(const int &Opt, const bool &Val)
Definition: lx.cpp:286
bool IsFrcEoln
Definition: lx.h:256
Definition: lx.h:49
Definition: fl.h:275
TLxSym AddRw(const TStr &Str)
Definition: lx.cpp:300
static const TStr PercentStr
Definition: lx.h:77
static const TStr PlusStr
Definition: lx.h:73
TLxChDefTy
Definition: lx.h:6
char GetUc(const char &Ch) const
Definition: lx.h:32
TLxSym Sym
Definition: lx.h:149
void PutIndent(const int &IndentLev)
Definition: lx.h:299
TStr Str
Definition: lx.h:110
TOLx(const PSOut &_SOut, const TFSet &OptSet, const TLxChDefTy &ChDefTy=lcdtUsAscii)
Definition: lx.cpp:718
static bool GetValFromStr(const TStr &Str)
Definition: dt.cpp:1850
char QuoteCh
Definition: lx.h:154
static bool IsSep(const TLxSym &PrevSym, const TLxSym &Sym)
Definition: lx.cpp:226
Definition: lx.h:126
TSOut & RSOut
Definition: lx.h:255
TStr GetTokStr(const bool &XmlP=true) const
Definition: xml.h:316
Definition: lx.h:126
TILxSymSt()
Definition: lx.cpp:244
static const char EofCh
Definition: dt.h:1037
static const char Mx
Definition: dt.h:1030
Definition: lx.h:107
static const TStr IntStr
Definition: lx.h:62
void SetOpt(const int &Opt, const bool &Val)
Definition: lx.cpp:728
void PutVarStrVV(const TStr &VarNm, const TVec< TStrV > &StrVV, const bool &NewLn=true, const bool &CheckIdStr=true)
Definition: lx.cpp:818
Definition: lx.h:50
TChA UcStr
Definition: lx.h:150
double Flt
Definition: lx.h:111
static PSIn New(const TStr &FNm)
Definition: fl.cpp:290
static void GetLnV(const TStr &FNm, TStrV &LnV)
Definition: lx.cpp:687
PSIn GetSIn(const char &SepCh)
Definition: lx.cpp:309
static const TStr HashStr
Definition: lx.h:82
TStr GetArgVal(const TStr &ArgNm) const
Definition: xml.h:273
int LnN
Definition: lx.h:135
Definition: lx.h:126
static const TStr QStrStr
Definition: lx.h:66
bool IsSigNum
Definition: lx.h:138
static const TStr VBarStr
Definition: lx.h:79
void Clr(const bool &DoDel=true, const TSizeTy &NoDelLim=-1)
Clears the contents of the vector.
Definition: ds.h:1022
Definition: lx.h:45
Definition: lx.h:6
TStr GetStrToCh(const char &ToCh)
Definition: lx.cpp:539
TLxSym GetSym()
Definition: lx.h:171
static const TStr EqStr
Definition: lx.h:83
PSIn SIn
Definition: lx.h:132
char * CStr()
Definition: dt.h:255
virtual bool Eof()=0
Definition: lx.h:5
bool IsVarIndent
Definition: lx.h:257
void PutAll(const TVal &Val)
Sets all elements of the vector to value Val.
Definition: ds.h:1229
Definition: dt.h:1025
static const char TabCh
Definition: dt.h:1034
static const char Mn
Definition: dt.h:1029
Definition: lx.h:47
TPreproc(const TStr &InFNm, const TStr &OutFNm, const TStr &SubstFNm, const TStrV &_SubstKeyIdV)
Definition: lx.cpp:857
char GetCh()
Definition: fl.h:302
Definition: lx.h:49
Definition: lx.h:51
Definition: lx.h:129
static const TStr SlashStr
Definition: lx.h:76
char PrevCh
Definition: lx.h:134
#define Assert(Cond)
Definition: bd.h:251
static const TStr LssStr
Definition: lx.h:85
bool IsUniStr
Definition: lx.h:138
static const TStr ExclamationStr
Definition: lx.h:78
void GetVarStrPrV(const TStr &VarNm, TStrPrV &StrPrV, const bool &NewLn=true)
Definition: lx.cpp:664
static const TStr RBraceStr
Definition: lx.h:94
bool IsExcept
Definition: lx.h:139
const TVal & Last() const
Returns a reference to the last element of the vector.
Definition: ds.h:579
TIntV ChTyV
Definition: lx.h:10
TStr GetQStr(const TStr &QStr=TStr())
Definition: lx.h:187
bool Eof()
Definition: fl.h:298
bool IsSigNum
Definition: lx.h:256
static const TStr GtrStr
Definition: lx.h:86
static const TStr LBracketStr
Definition: lx.h:91
char GetCh()
Definition: lx.cpp:834
Definition: lx.h:50
static const TStr AsteriskStr
Definition: lx.h:75
bool IsNum(const char &Ch) const
Definition: lx.h:29
static const TStr FltStr
Definition: lx.h:63
char GetCh(const int &ChN) const
Definition: dt.h:483
bool IsCmtAlw
Definition: lx.h:138
void Trunc()
Definition: dt.cpp:420
void PutFlt(const TFlt &Flt, const int &Width=-1, const int &Prec=-1)
Definition: lx.h:280
Definition: lx.h:49
Definition: lx.h:45
TChA Str
Definition: lx.h:150
static const char LfCh
Definition: dt.h:1035
bool IsCmtAlw
Definition: lx.h:256
static const TStr LBraceStr
Definition: lx.h:93
Definition: dt.h:1134
Definition: lx.h:249
Definition: lx.h:248
TChV UcChV
Definition: lx.h:11
Definition: lx.h:8
int GetKeyId(const TKey &Key) const
Definition: hash.h:466
TSStack< TILxSymSt > PrevSymStStack
Definition: lx.h:136
Definition: lx.h:127
bool Bool
Definition: lx.h:151
Definition: lx.h:47
Definition: dt.h:201
int SymLnChN
Definition: lx.h:112
void Push()
Definition: ds.h:2596
Definition: ut.h:161
void GetVarStrVV(const TStr &VarNm, TVec< TStrV > &StrVV, const bool &NewLn=true)
Definition: lx.cpp:675
Definition: lx.h:48
TLxSym PeekSym()
Definition: lx.h:200
bool IsBof() const
Definition: lx.h:167
void SetChTy(const TLxChTy &ChTy, const TStr &Str)
Definition: lx.cpp:8
int SymLnChN
Definition: lx.h:152
char GetCh()
Definition: lx.h:140
static const TStr EolnStr
Definition: lx.h:95
static bool IsValStr(const TStr &Str)
Definition: dt.cpp:1842
static TLxSym GetSSym(const TStr &Str)
Definition: lx.cpp:186
static const TStr SemicolonStr
Definition: lx.h:72
Definition: lx.h:46
Definition: lx.h:50
int SymLnN
Definition: lx.h:112
void Pop()
Definition: ds.h:2598
static const TStr UndefStr
Definition: lx.h:58
Definition: dt.h:412
static const TStr NEqStr
Definition: lx.h:84
bool Empty() const
Definition: dt.h:488
static const TStr DColonStr
Definition: lx.h:71
int LnChN
Definition: lx.h:135
Definition: lx.h:249
int PutStr(const char *CStr)
Definition: fl.cpp:117
void GetTagTokV(const TStr &TagPath, TXmlTokV &XmlTokV) const
Definition: xml.cpp:1158
bool IsTerm(const char &Ch) const
Definition: lx.h:26
TLxSym PrevSym
Definition: lx.h:261
PSIn SIn
Definition: lx.h:362
static const TStr LEqStr
Definition: lx.h:87
TIntStrH RwSymH
Definition: lx.h:260
static const char CrCh
Definition: dt.h:1036
void SetUcCh(const TStr &Str)
Definition: lx.cpp:3
#define EAssertR(Cond, MsgStr)
Definition: bd.h:283
static TStr GetSymStr(const TLxSym &Sym)
Definition: lx.cpp:142
Definition: lx.h:46
static PXmlDoc LoadTxt(TXmlLx &Lx)
Definition: xml.cpp:1401
static const TStr LnStr
Definition: lx.h:59
PLxChDef ChDef
Definition: lx.h:131
void GetVarBoolV(const TStr &VarNm, TBoolV &BoolV, const bool &NewLn=true)
Definition: lx.cpp:632
static const TStr StrStr
Definition: lx.h:64
virtual TStr GetSNm() const
Definition: fl.cpp:20
static const TStr IdStrStr
Definition: lx.h:65
int Int
Definition: lx.h:151
void PutVarEnd(const bool &RBracket=false, const bool &NewLn=false)
Definition: lx.h:315
bool IsCsSens
Definition: lx.h:257
TStr GetStrToEolnAndCh(const char &ToCh)
Definition: lx.cpp:561
Definition: lx.h:47
int SymChN
Definition: lx.h:152
bool Bool
Definition: lx.h:111
TStr UcStr
Definition: lx.h:110
Definition: lx.h:46
TStr GetUcStr(const TStr &Str) const
Definition: lx.cpp:71
Definition: lx.h:5
Definition: lx.h:248
Definition: lx.h:45
char Ch
Definition: lx.h:364
int SymChN
Definition: lx.h:112
static PLxChDef GetChDef(const TLxChDefTy &ChDefTy=lcdtUsAscii)
Definition: lx.cpp:79
static const TStr PeriodStr
Definition: lx.h:67
virtual char GetCh()=0
THash< TStr, TStrPrV > SubstIdToKeyIdValPrVH
Definition: lx.h:365
int EncodeUtf8(const TIntV &src, TIntV &dest) const
Definition: unicode.h:1792
TStr GetFPosStr() const
Definition: lx.cpp:607
Definition: lx.h:127
static const TStr MinusStr
Definition: lx.h:74
Definition: lx.h:248
static const TStr GEqStr
Definition: lx.h:88
TLxSym Sym
Definition: lx.h:109
static const TStr RBracketStr
Definition: lx.h:92
TChA & ToTrunc()
Definition: dt.cpp:568
char * CStr()
Definition: dt.h:476
char Pop()
Definition: dt.h:265
bool IsKey(const TKey &Key) const
Definition: hash.h:258
Definition: lx.h:46
Definition: lx.h:45
TSizeTy Add()
Adds a new element at the end of the vector, after its current last element.
Definition: ds.h:602
TChA CmtStr
Definition: lx.h:150
Definition: lx.h:249
bool IsNmStr(const TStr &Str) const
Definition: lx.cpp:63
static const TStr TabStr
Definition: lx.h:60
int Len() const
Definition: hash.h:228
Definition: lx.h:46
TDat & AddDat(const TKey &Key)
Definition: hash.h:238
Definition: lx.h:48
Definition: lx.h:50
void PutVarIntV(const TStr &VarNm, const TIntV &IntV, const bool &NewLn=true, const bool &CheckIdStr=true)
Definition: lx.cpp:772
double Flt
Definition: lx.h:151
void PutVarStrV(const TStr &VarNm, const TStrV &StrV, const bool &NewLn=true, const bool &CheckIdStr=true)
Definition: lx.cpp:794
static const TStr LParenStr
Definition: lx.h:89
static const TStr RParenStr
Definition: lx.h:90
TStr CmtStr
Definition: lx.h:110
void PutVarFltV(const TStr &VarNm, const TFltV &FltV, const bool &NewLn=true, const bool &CheckIdStr=true)
Definition: lx.cpp:783
Definition: lx.h:127
Definition: lx.h:126
static const TStr AmpersandStr
Definition: lx.h:80
TStrIntH RwStrH
Definition: lx.h:259
bool In(const int &FlagN) const
Definition: bits.h:156