const Number FloatLiteralParser::ParseFractional(NumberBuilder & numberBuilder)
{
// Assert( NeedChar() == '.' )
numberBuilder.SetFloat();
Advance();
if (AtEnd() || NotInClass(CharClass::DECIMAL))
{
if (config_.allow_trailing_point)
{
return numberBuilder.Release();
}
ThrowError("Decimal digit expected");
}
do
{
numberBuilder.OnFractionalDigit(GetChar() - '0');
Advance();
if (AtEnd())
{
return numberBuilder.Release();
}
}
while (InClass(CharClass::DECIMAL));
char c = GetChar();
if (c == 'e' || c == 'E')
{
return ParseExponent(numberBuilder);
}
return numberBuilder.Release();
}
void StringTokenizer::GetNextToken()
{
// skip till end of token
while( !AtEnd() && IsWhitespace(*mCurrentPos) )
mCurrentPos++;
// this is the start of the token
mCurToken = (char*)mCurrentPos;
// skip till end of token
for(; !AtEnd(); ++mCurrentPos)
{
if( IsWhitespace(*mCurrentPos) )
break;
if( IsDelimiter(*mCurrentPos) )
{
if( mCurrentPos == (Byte*)mCurToken )
++mCurrentPos;
break;
}
}
// end of search condition
if( mCurrentPos == (Byte*)mCurToken )
{
mCurToken = 0;
mCurTokenLength = 0;
}
else
{
mCurTokenLength = mCurrentPos - (Byte*)mCurToken;
}
}
//{
// WriteMask
// ReadMask
// Ref
// Comp
// Pass
// Fail
// ZFail
// }
NodePtr Parser::StencilBlock()
{
if (!Match(Token::TOK_LEFT_BRACE))
return nullptr;
NodePtr stencilNode = std::make_unique<StencilNode>();
while (!AtEnd()) {
if (LookAhead(Token::TOK_RIGHT_BRACE)) {
Consume();
break;
}
auto Next = Consume();
FnInfix infix = s_StencilExpr[Next.GetType()].second;
if (infix) {
stencilNode = (this->*infix)(std::move(stencilNode), Next);
} else {
SpawnError("Parsing stencil block failed", "Unexpected token");
break;
}
if (AtEnd()) {
SpawnError("Unexpected EoF in Stencil block", "'}' expected");
return nullptr;
}
}
return stencilNode;
}
bool CNumberRangeEnumerator::MoveToNext()
{
if (!AtEnd())
{
m_iEnumerator++;
}
return AtEnd();
}
void CValidError_CI::Next(void)
{
if ( AtEnd() ) {
return;
}
do {
++m_Current;
} while ( !AtEnd() && !Filter(**m_Current) );
}
const Number IntegerLiteralParser::Parse()
{
// Assert( NotAtEnd() && InClass(CharClass::NUMBER_HEAD) )
char c = GetChar();
IntegerBuilder integerBuilder;
if (c == '0')
{
Advance();
if (AtEnd())
{
return Number::ZERO();
}
switch (GetChar())
{
case 'b' : return ParseBinary();
case 'x' : return ParseHexadecimal();
}
if (NotInClass(CharClass::DECIMAL))
{
return Number::ZERO();
}
// if (config_.parse_octal)
{
return ParseOctal();
}
}
else if (c == '-')
{
integerBuilder.SetNegative();
Advance();
if (AtEnd() || NotInClass(CharClass::DECIMAL))
{
ThrowError("Decimal digit expected");
}
}
// Assert( NotAtEnd() && InClass(CharClass::DECIMAL) )
do
{
integerBuilder.OnDecimalDigit(GetChar() - '0');
Advance();
}
while (NotAtEnd() && InClass(CharClass::DECIMAL));
return integerBuilder.Release();
}
bool hsStream::ReadLn(char *s, uint32_t maxLen, const char beginComment, const char endComment)
{
char c;
char endCom;
endCom = endComment;
while( true )
{
while( !AtEnd() && strchr("\r\n",c = ReadByte()) )
c = c;
;
if( AtEnd() )
return false;
if( beginComment != c )
break;
// skip to end of comment
while( !AtEnd() && (endCom != (c = ReadByte())) )
c= c;
;
}
s[0] = c;
uint32_t k = 1;
while( !AtEnd() && !strchr("\r\n",c = ReadByte()) )
{
if( k < maxLen )
s[k++] = c;
}
s[k] = 0;
if( (k > 0)&&!stricmp(s, "skip") )
{
int depth = 1;
while( depth && ReadLn(s, maxLen, beginComment, endCom) )
{
if( !stricmp(s, "skip") )
depth++;
else
if( !stricmp(s, "piks") )
depth--;
}
return ReadLn(s, maxLen, beginComment, endCom);
}
return true;
}
bool TGztParser::ParseArticleBlock(NProtoBuf::RepeatedPtrField<TArticleFieldDescriptorProto>* article_fields)
{
DO(Consume("{"));
bool had_keyword_fields = false;
while (!TryConsume('}')) {
if (AtEnd()) {
AddError("Reached end of input in article definition (missing '}').");
return false;
}
if (!ParseArticleField(article_fields))
// This statement failed to parse. Skip it, but keep looping to parse
// other statements.
SkipStatement();
else {
//check if there is forbidden keyword/positional fields sequence
bool last_is_keyword_field = article_fields->Get(article_fields->size()-1).has_name();
if (last_is_keyword_field)
had_keyword_fields = true;
else if (had_keyword_fields) {
AddError("Positional field (i.e. only a value without explicit field name) could not be used after non-positional (named) fields.");
SkipStatement();
}
}
}
return true;
}
void MeaXMLNode::Dump() const
{
static int indent = 0;
CString indentStr(_T(' '), indent);
TRACE(_T("%sNode Type: "), (LPCTSTR)indentStr);
switch (m_type) {
case Unknown:
TRACE(_T("Unknown\n"));
break;
case Element:
TRACE(_T("Element - %s\n"), m_data);
break;
case Data:
TRACE(_T("Data - '%s'\n"), m_data);
break;
}
for (NodeIter_c iter = GetChildIter(); !AtEnd(iter); ++iter) {
indent += 4;
(*iter)->Dump();
indent -= 4;
}
}
/// Tokenize the string using the specified set of char delimiters.
///
/// @param target
/// Output container.
/// Tokens defined in "str" by using symbols from "delim" are added
/// to the list "target".
/// @param token_pos
/// Container for the tokens' positions in "str".
/// @param empty_str
/// String added to target when there are no other characters between
/// delimiters
///
void Do(TContainer& target,
TPosContainer& token_pos,
const TString& empty_str = TString())
{
// Special cases
if (m_Str.empty()) {
return;
} else if (m_Delim.empty()) {
target.push_back(m_Str);
token_pos.push_back(0);
return;
}
// Do target space reservation (if applicable)
TReserveTrait::Reserve(*this, target, token_pos);
// Reposition to just after any initial delimiters
m_Pos = 0;
SkipDelims();
// Tokenization
//
CTempStringList part_collector(m_Storage);
SIZE_TYPE prev_pos;
do {
prev_pos = m_Pos;
if (Advance(&part_collector)) {
target.push_back(empty_str);
part_collector.Join(&target.back());
part_collector.Clear();
token_pos.push_back(prev_pos);
}
} while ( !AtEnd() );
}
/*----------------------------------------------------------------------------------------------
Get the current feature values and character properties from the stream.
----------------------------------------------------------------------------------------------*/
void GrCharStream::CurrentFeatures(GrTableManager * ptman, GrFeatureValues * pfval)
{
if (m_ichrRunOffset == kPosInfinity)
{
// Not yet set up.
if (AtEnd())
{
// Empty stream; no valid values.
Assert(false);
return;
}
// Get the settings from the first character.
int ichrSegOffset;
int ichrPosSave = m_ichrPos;
int ichrRunOffsetSave = m_ichrRunOffset;
int ichlRunOffsetSave = m_ichlRunOffset;
int cMapSize = m_vislotNextChunkMap.size();
int cchrConsumed;
NextGet(ptman, pfval, &ichrSegOffset, &cchrConsumed);
// Put the character back.
m_ichrPos = ichrPosSave;
m_ichrRunOffset = ichrRunOffsetSave;
m_ichlRunOffset = ichlRunOffsetSave;
while (signed(m_vislotNextChunkMap.size()) > cMapSize)
m_vislotNextChunkMap.pop_back();
}
else
{
*pfval = m_fvalRunFeats;
//*ppchrp = &m_chrpRun;
}
}
bool TGztParser::ParseBracketedValuesList(TFieldValueDescriptorProto* value)
{
DO(Consume("["));
value->set_type(TFieldValueDescriptorProto::TYPE_LIST);
value->mutable_list()->set_type(TValuesListDescriptorProto::BRACKETED);
bool last_was_delimiter = false;
while (last_was_delimiter || !TryConsume(']')) {
if (AtEnd()) {
AddError("Unexpected end of stream while parsing bracketed list.");
return false;
}
if (LookingAt('}')) {
AddError("Missing ']'.");
return false;
}
// Note that a bracketed list could contain any type of sub-value, including sub-lists of any type.
DO(ParseChainedFieldValues(value->mutable_list()->add_value()));
// consume items delimiter (if any), but only one.
if (TryConsume(','))
last_was_delimiter = true;
else
last_was_delimiter = TryConsume(';');
}
return true;
}
void AudioPrefsDialog::load()
{
bug_fun();
cfg.load();
cfg.dump();
for(auto page: pages)
{
bug_var(page);
for(auto iter = page->GetIterator(); !iter.AtEnd(); iter.Next())
{
auto prop = iter.GetProperty();
auto key = prop->GetName().ToStdString();
if(!cfg.has(key))
continue;
if(auto p = dynamic_cast<wxStringProperty*>(prop))
p->SetValueFromString(cfg.get(key, p->GetDefaultValue().GetString().ToStdString()));
else if(auto p = dynamic_cast<wxColourProperty*>(prop))
{}
else if(auto p = dynamic_cast<wxEnumProperty*>(prop))
{
p->SetValueFromString(cfg.get(key, p->GetDefaultValue().GetString().ToStdString()));
}
else if(auto p = dynamic_cast<wxIntProperty*>(prop))
p->SetValueFromInt(cfg.get(key, p->GetDefaultValue().GetInteger()));
else if(auto p = dynamic_cast<wxFontProperty*>(prop))
{
bug_var(p->GetValue().GetString().ToStdString());
p->SetValueFromInt(cfg.get(key, p->GetDefaultValue().GetInteger()));
}
}
}
}
bool TGztParser::ParseImports(Tokenizer* input, TGztFileDescriptorProto* file)
{
TTokenizer tokenizer(input);
Start(&tokenizer);
if (CurrentEncoding() != CODES_UNKNOWN)
file->set_encoding(NameByCharset(CurrentEncoding()));
// Repeatedly parse statements until we reach the end of the file.
while (!AtEnd())
{
if (TryConsume(';'))
// empty statement; ignore
continue;
if (!LookingAt("import") || !ParseImport(file->add_dependency()))
{
// Parse imports or skip whole statement, but keep looping to parse
// other statements.
SkipStatement();
SkipBlockEnd();
}
}
return Finish();
}
void RubberGroup::RemoveCur() {
RubberList* doomed = cur;
if (!AtEnd()) {
cur = cur->Next();
rlist->Delete(doomed);
}
}
char Parser::NeedChar() const
{
if (AtEnd())
{
throw EndOfFile();
}
return GetChar();
}
Boolean PtrDynArrayIterator<T>::More() const
{
if (_ArrayVarPtr->RunLength() == 0)
{
PtrDynArrayIterator<T>* const LocalThis_ = (PtrDynArrayIterator<T>* const)this;
LocalThis_->_Index = SizeType(-1);
}
return !AtEnd();
}
PtrDynArrayIterator<T>& PtrDynArrayIterator<T>::operator = (T* Ptr_)
{
if (_ArrayVarPtr == NULL)
Xnullp();
if (!AtEnd())
(*_ArrayVarPtr)[_Index] = Ptr_;
return *this;
}
bool Parser::SkipChar(char c)
{
if (AtEnd() || GetChar() != c)
{
return false;
}
Advance();
return true;
}
// Adjust the weights of all the samples to be uniform in the given charset.
// Returns the number of samples in the iterator.
int SampleIterator::UniformSamples() {
int num_good_samples = 0;
for (Begin(); !AtEnd(); Next()) {
TrainingSample* sample = MutableSample();
sample->set_weight(1.0);
++num_good_samples;
}
NormalizeSamples();
return num_good_samples;
}
void Advance()
{
if (AtEnd())
{
return;
}
++current_;
FindNextBit();
}
PictSelection::PictSelection (Graphic* gs) : (gs) {
valid = true;
}
// PictSelection knows it's the outermost PictSelection because it was
// called with a FILE* pointer, so it must read a version number, skip
// over its name, read its graphic state and children, and scale
// itself back to screen coordinates when it's finished.
PictSelection::PictSelection (FILE* stream, State* state) : (nil) {
int fd = fileno(stream);
istream from(fd);
ReadVersion(from);
ReadGridSpacing(from);
if (versionnumber < 3) {
Skip(from);
}
ReadPictGS(from, state);
ReadChildren(from, state);
ScaleToScreenCoords();
valid = from.good();
}
// Copy returns a copy of the PictSelection.
Graphic* PictSelection::Copy () {
Selection* copy = new PictSelection(this);
for (First(); !AtEnd(); Next()) {
copy->Append(GetCurrent()->Copy());
}
return copy;
}
// HasChildren returns true so Idraw can ungroup this Picture.
boolean PictSelection::HasChildren () {
return Picture::HasChildren();
}
// Propagate must preserve the PictSelection's transformation matrix
// if it has any.
void PictSelection::Propagate () {
Transformer* original = GetTransformer();
if (original != nil) {
original->Reference();
Selection::Propagate();
SetTransformer(original);
delete original;
} else {
Selection::Propagate();
}
}
// Normalize the weights of all the samples in the charset_map so they sum
// to 1. Returns the minimum assigned sample weight.
double SampleIterator::NormalizeSamples() {
double total_weight = 0.0;
int sample_count = 0;
for (Begin(); !AtEnd(); Next()) {
const TrainingSample& sample = GetSample();
total_weight += sample.weight();
++sample_count;
}
// Normalize samples.
double min_assigned_sample_weight = 1.0;
if (total_weight > 0.0) {
for (Begin(); !AtEnd(); Next()) {
TrainingSample* sample = MutableSample();
double weight = sample->weight() / total_weight;
if (weight < min_assigned_sample_weight)
min_assigned_sample_weight = weight;
sample->set_weight(weight);
}
}
return min_assigned_sample_weight;
}
const char* CTokenParser::NextCSVToken(CString &s)
{
s = NextToken(); //get value
if (s==",")
s = "";
else
{
if (!AtLastToken() && !AtEnd())
NextToken(); //get ',' separater
}
return (const char*)s;
}
void PictSelection::WriteData (ostream& to) {
to << "Begin " << startdata << " Pict\n";
WritePictGS(to);
to << "\n";
for (First(); !AtEnd(); Next()) {
Selection* s = GetCurrent();
s->WriteData(to);
}
to << "End " << startdata << " eop\n\n";
}
PtrDynArrayIterator<T>& PtrDynArrayIterator<T>::operator [] (SizeType Index_)
{
if (_ArrayVarPtr == NULL)
Xnullp();
_Index = Index_;
if (!AtEnd())
((*_ArrayVarPtr)[_Index]);
else
((*_ArrayVarPtr)[0]);
return *this;
}
bool TGztParser::Parse(Tokenizer* input, TGztFileDescriptorProto* file)
{
TTokenizer tokenizer(input);
Start(&tokenizer);
if (CurrentEncoding() != CODES_UNKNOWN)
file->set_encoding(NameByCharset(CurrentEncoding()));
// Repeatedly parse statements until we reach the end of the file.
while (!AtEnd())
ParseTopLevelStatementOrSkip(file);
return Finish();
}
const Number FloatLiteralParser::ParseExponent(NumberBuilder & numberBuilder)
{
// Assert( NeedChar() == 'e' || NeedChar() == 'E' )
numberBuilder.SetFloat();
Advance();
if (AtEnd())
{
ThrowError("Decimal digit expected");
}
switch (GetChar())
{
case '-':
numberBuilder.SetNegativeExponent();
case '+':
Advance();
if (AtEnd())
{
ThrowError("Decimal digit expected");
}
break;
}
if (NotInClass(CharClass::DECIMAL))
{
ThrowError("Decimal digit expected");
}
do
{
numberBuilder.OnExponentDigit(GetChar() - '0');
Advance();
}
while (NotAtEnd() && InClass(CharClass::DECIMAL));
return numberBuilder.Release();
}
const Number IntegerLiteralParser::ParseHexadecimal()
{
// Assert( NeedChar() == 'x' )
IntegerBuilder integerBuilder;
Advance();
if (AtEnd() || NotInClass(CharClass::HEXADECIMAL))
{
ThrowError("Hexadecimal digit expected");
}
try
{
do
{
integerBuilder.OnHexadecimalDigit(HexToInt(GetChar()));
Advance();
if (AtEnd())
{
return integerBuilder.Release();
}
}
while (InClass(CharClass::HEXADECIMAL));
}
catch (const IntegerBuilder::OverflowError &)
{
ThrowError("Hexadecimal number is too big");
}
if (InClass(CharClass::LETTER))
{
ThrowError("Hexadecimal digit expected");
}
return integerBuilder.Release();
}
const Number IntegerLiteralParser::ParseBinary()
{
// Assert( NeedChar() == 'b' )
IntegerBuilder integerBuilder;
Advance();
if (AtEnd() || NotInClass(CharClass::BINARY))
{
ThrowError("Binary digit expected");
}
try
{
do
{
integerBuilder.OnBinaryDigit(GetChar() - '0');
Advance();
if (AtEnd())
{
return integerBuilder.Release();
}
}
while (InClass(CharClass::BINARY));
}
catch (const IntegerBuilder::OverflowError &)
{
ThrowError("Binary number is too big");
}
if (InClass(CharClass::DECIMAL))
{
ThrowError("Binary digit expected");
}
return integerBuilder.Release();
}