/*
* ATIMach64SubsequentSolidHorVertLine --
*
* This is called to draw a solid horizontal or vertical line. This does a
* one-pixel wide solid fill.
*/
static void
ATIMach64SubsequentSolidHorVertLine
(
ScrnInfoPtr pScreenInfo,
int x,
int y,
int len,
int dir
)
{
ATIPtr pATI = ATIPTR(pScreenInfo);
ATIDRISync(pScreenInfo);
ATIMach64WaitForFIFO(pATI, 3);
outf(DST_CNTL, DST_X_DIR | DST_Y_DIR);
outf(DST_Y_X, SetWord(x, 1) | SetWord(y, 0));
if (dir == DEGREES_0)
outf(DST_HEIGHT_WIDTH, SetWord(len, 1) | SetWord(1, 0));
else /* if (dir == DEGREES_270) */
outf(DST_HEIGHT_WIDTH, SetWord(1, 1) | SetWord(len, 0));
}
/*
* ATIMach64SubsequentScanlineCPUToScreenColorExpandFill --
*
* This function sets up the engine for a single colour expansion fill.
*/
static void
ATIMach64SubsequentScanlineCPUToScreenColorExpandFill
(
ScrnInfoPtr pScreenInfo,
int x,
int y,
int w,
int h,
int skipleft
)
{
ATIPtr pATI = ATIPTR(pScreenInfo);
ATIDRISync(pScreenInfo);
if (pATI->XModifier != 1)
{
x *= pATI->XModifier;
w *= pATI->XModifier;
skipleft *= pATI->XModifier;
outf(DST_CNTL, SetBits((x / 4) % 6, DST_24_ROT) |
(DST_X_DIR | DST_Y_DIR | DST_24_ROT_EN));
}
pATI->ExpansionBitmapWidth = (w + 31) / 32;
ATIMach64WaitForFIFO(pATI, 3);
pATI->sc_left = x + skipleft;
pATI->sc_right = x + w - 1;
outf(SC_LEFT_RIGHT,
SetWord(pATI->sc_right, 1) | SetWord(pATI->sc_left, 0));
outf(DST_Y_X, SetWord(x, 1) | SetWord(y, 0));
outf(DST_HEIGHT_WIDTH,
SetWord(pATI->ExpansionBitmapWidth * 32, 1) | SetWord(h, 0));
}
void
SetFeatures::SetIntVecConfigIV(uint16_t iv)
{
LOG_NRM("Setting interrupt vector (IV): 0x%04X", iv);
SetWord(iv, 11, 0);
}
void
SetFeatures::SetNumberOfQueuesNSQR(uint16_t nsqr)
{
LOG_NRM("Setting Set Features(Number of SQs): NSQR=0x%04X", nsqr);
SetWord(nsqr, 11, 0);
}
void
SetFeatures::SetNumberOfQueuesNCQR(uint16_t ncqr)
{
LOG_NRM("Setting Set Features(Number of CQs): NCQR=0x%04X", ncqr);
SetWord(ncqr, 11, 1);
}
void
SetFeatures::SetErrRecoveryTLER(uint16_t tler)
{
LOG_NRM("Setting error recovery retry timeout (TLER): 0x%04X", tler);
SetWord(tler, 11, 0);
}
void
SetFeatures::SetTempThresholdTMPTH(uint16_t tmpth)
{
LOG_NRM("Setting temperature threshold (TMPTH): 0x%04X in Kelvin", tmpth);
SetWord(tmpth, 11, 0);
}
void
GetLogPage::SetLID(uint16_t logID)
{
LOG_NRM("Setting LID 0x%04X", logID);
SetWord(logID, 10, 0);
}
bool CPlmLine :: LoadPlmLineFromString (string LineStr, bool bStartLine, const CAgramtab* pRusGramTab)
{
m_bToDelete = false;
m_bQuoteMarks = false;
if (!bStartLine)
{
m_bHomonym = (LineStr[0] == ' ');
Trim(LineStr);
SetWord(::GetWordForm(LineStr) );
}
else
{
m_bHomonym = false;
SetWord( "" );
};
long i = 1; // the first char can be a space (if this line contains a homonym)
for (; i < LineStr.length(); i++)
if (!isspace((BYTE) LineStr[i]) == 0)
break;
if (sscanf (LineStr.c_str()+i, "%i %i", &m_FilePosition, &m_TokenLengthInFile) != 2)
return false;
// pass all numbers
for (; i < LineStr.length(); i++)
if ( (isdigit((BYTE) LineStr[i]) == 0)
&& (isspace((BYTE) LineStr[i]) == 0)
&& (((BYTE)LineStr[i]) != '-')
)
break;
int MorphSignPos = GetMorphSignPosition(LineStr.c_str()+i);
if (MorphSignPos == -1)
MorphSignPos = LineStr.length();
else
MorphSignPos += i; // make MorphSignPos an absolute offset in LineStr
m_GraphDescr = LineStr.substr (i, MorphSignPos - i);
/* вставим пробел в начало, потому что часто ищут графету с пробелом в начале,
например, " ЛЕ"*/
m_GraphDescr = " " + m_GraphDescr;
if (MorphSignPos != LineStr.length())
{
StringTokenizer tok(LineStr.c_str()+MorphSignPos," ");
if (!tok() ) return false;
string MorphSign = tok.val();
if (MorphSign.length() != 3) return false;
m_MorphSign = MorphSign[0];
m_CommonGramCode = MorphSign.substr(1);
if (!tok() ) return false;
m_Lemma = tok.val();
if (m_Lemma.empty()) return false;
if (!tok() ) return false;
SetGramCodes ( tok.val(), pRusGramTab);
if (!tok() ) return false;
m_ParadigmId = tok.val();
if (!tok() ) return false;
m_HomoWeight = tok.val();
};
m_TokenType = OTHER_TOKEN_TYPE;
for (int k=(int)RLE; k < OTHER_TOKEN_TYPE; k++)
if (init_flag (m_GraphDescr, TokenTypeToString((MainTokenTypeEnum)k).c_str() ))
{
m_TokenType = (MainTokenTypeEnum)k;
break;
};
if (init_flag (m_GraphDescr, "Aa"))
m_Register = UpLow;
else
if (init_flag (m_GraphDescr, "AA"))
m_Register = UpUp;
else
{
init_flag (m_GraphDescr, "aa");
m_Register = LowLow;
};
m_bFirstUpperAlpha = (m_Register == UpUp) || (m_Register == UpLow);
m_bFI1 = init_flag (m_GraphDescr, "FAM1");
m_bFI2 = init_flag (m_GraphDescr, "FAM2");
m_bName = init_flag (m_GraphDescr, "NAM?");
m_bSent2 = init_flag (m_GraphDescr, "SENT_END");
int hyphen_occur = m_Word.find("-");
m_bHyphenWord = (hyphen_occur != string::npos) && ( (m_TokenType == RLE) ||(m_TokenType == LLE));
m_bOborot1 = (m_GraphDescr.find("EXPR1") != string::npos);
m_bOborot2 = (m_GraphDescr.find("EXPR2") != string::npos);
bool bRomanNumber = is_roman_number(m_Word.c_str(), m_Word.length());
if ((hyphen_occur != string::npos) && (hyphen_occur!=0))
{
// "Павла I-го"
// "I-го" - одно слово
bRomanNumber = is_roman_number(m_Word.c_str(), hyphen_occur);
};
if (bRomanNumber)
{
m_TokenType = ROMAN_NUM;
m_CommonGramCode = "";
m_MorphSign = 0;
m_ParadigmId = "";
};
Trim(m_GraphDescr);
return true;
};
/*
* ATIMach64Sync --
*
* This is called to wait for the draw engine to become idle.
*/
void
ATIMach64Sync
(
ScrnInfoPtr pScreenInfo
)
{
ATIPtr pATI = ATIPTR(pScreenInfo);
#ifdef XF86DRI_DEVEL
if ( pATI->directRenderingEnabled && pATI->NeedDRISync )
{
ATIHWPtr pATIHW = &pATI->NewHW;
if (pATI->OptionMMIOCache) {
/* "Invalidate" the MMIO cache so the cache slots get updated */
UncacheRegister(SRC_CNTL);
UncacheRegister(HOST_CNTL);
UncacheRegister(PAT_CNTL);
UncacheRegister(SC_LEFT_RIGHT);
UncacheRegister(SC_TOP_BOTTOM);
UncacheRegister(DP_BKGD_CLR);
UncacheRegister(DP_FRGD_CLR);
UncacheRegister(DP_WRITE_MASK);
UncacheRegister(DP_MIX);
UncacheRegister(CLR_CMP_CNTL);
}
ATIDRIWaitForIdle(pATI);
outr( BUS_CNTL, pATIHW->bus_cntl );
/* DRI uses GUI_TRAJ_CNTL, which is a composite of
* src_cntl, dst_cntl, pat_cntl, and host_cntl
*/
outf( SRC_CNTL, pATIHW->src_cntl );
outf( DST_CNTL, pATIHW->dst_cntl );
outf( PAT_CNTL, pATIHW->pat_cntl );
outf( HOST_CNTL, pATIHW->host_cntl );
outf( DST_OFF_PITCH, pATIHW->dst_off_pitch );
outf( SRC_OFF_PITCH, pATIHW->src_off_pitch );
outf( DP_SRC, pATIHW->dp_src );
outf( DP_MIX, pATIHW->dp_mix );
outf( DP_FRGD_CLR, pATIHW->dp_frgd_clr );
outf( DP_WRITE_MASK, pATIHW->dp_write_mask );
outf( DP_PIX_WIDTH, pATIHW->dp_pix_width );
outf( CLR_CMP_CNTL, pATIHW->clr_cmp_cntl );
outf( ALPHA_TST_CNTL, 0 );
outf( Z_CNTL, 0 );
outf( SCALE_3D_CNTL, 0 );
ATIMach64WaitForFIFO(pATI, 2);
outf( SC_LEFT_RIGHT,
SetWord(pATIHW->sc_right, 1) | SetWord(pATIHW->sc_left, 0) );
outf( SC_TOP_BOTTOM,
SetWord(pATIHW->sc_bottom, 1) | SetWord(pATIHW->sc_top, 0) );
if (pATI->OptionMMIOCache) {
/* Now that the cache slots reflect the register state, re-enable MMIO cache */
CacheRegister(SRC_CNTL);
CacheRegister(HOST_CNTL);
CacheRegister(PAT_CNTL);
CacheRegister(SC_LEFT_RIGHT);
CacheRegister(SC_TOP_BOTTOM);
CacheRegister(DP_BKGD_CLR);
CacheRegister(DP_FRGD_CLR);
CacheRegister(DP_WRITE_MASK);
CacheRegister(DP_MIX);
CacheRegister(CLR_CMP_CNTL);
}
ATIMach64WaitForIdle(pATI);
if (pATI->OptionMMIOCache && pATI->OptionTestMMIOCache) {
/* Only check registers we didn't restore */
TestRegisterCaching(PAT_REG0);
TestRegisterCaching(PAT_REG1);
TestRegisterCaching(CLR_CMP_CLR);
TestRegisterCaching(CLR_CMP_MSK);
if (pATI->Block1Base)
{
TestRegisterCaching(OVERLAY_Y_X_START);
TestRegisterCaching(OVERLAY_Y_X_END);
TestRegisterCaching(OVERLAY_GRAPHICS_KEY_CLR);
TestRegisterCaching(OVERLAY_GRAPHICS_KEY_MSK);
TestRegisterCaching(OVERLAY_KEY_CNTL);
TestRegisterCaching(OVERLAY_SCALE_INC);
TestRegisterCaching(OVERLAY_SCALE_CNTL);
TestRegisterCaching(SCALER_HEIGHT_WIDTH);
TestRegisterCaching(SCALER_TEST);
TestRegisterCaching(VIDEO_FORMAT);
if (pATI->Chip < ATI_CHIP_264VTB)
{
TestRegisterCaching(BUF0_OFFSET);
TestRegisterCaching(BUF0_PITCH);
TestRegisterCaching(BUF1_OFFSET);
TestRegisterCaching(BUF1_PITCH);
}
else
{
TestRegisterCaching(SCALER_BUF0_OFFSET);
TestRegisterCaching(SCALER_BUF1_OFFSET);
TestRegisterCaching(SCALER_BUF_PITCH);
TestRegisterCaching(OVERLAY_EXCLUSIVE_HORZ);
TestRegisterCaching(OVERLAY_EXCLUSIVE_VERT);
if (pATI->Chip >= ATI_CHIP_264GTPRO)
{
TestRegisterCaching(SCALER_COLOUR_CNTL);
TestRegisterCaching(SCALER_H_COEFF0);
TestRegisterCaching(SCALER_H_COEFF1);
TestRegisterCaching(SCALER_H_COEFF2);
TestRegisterCaching(SCALER_H_COEFF3);
TestRegisterCaching(SCALER_H_COEFF4);
TestRegisterCaching(SCALER_BUF0_OFFSET_U);
TestRegisterCaching(SCALER_BUF0_OFFSET_V);
TestRegisterCaching(SCALER_BUF1_OFFSET_U);
TestRegisterCaching(SCALER_BUF1_OFFSET_V);
}
}
}
}
pATI->NeedDRISync = FALSE;
}
else
#endif /* XF86DRI_DEVEL */
{
ATIMach64WaitForIdle(pATI);
if (pATI->OptionMMIOCache && pATI->OptionTestMMIOCache)
{
/*
* For debugging purposes, attempt to verify that each cached register
* should actually be cached.
*/
TestRegisterCaching(SRC_CNTL);
TestRegisterCaching(HOST_CNTL);
TestRegisterCaching(PAT_REG0);
TestRegisterCaching(PAT_REG1);
TestRegisterCaching(PAT_CNTL);
if (RegisterIsCached(SC_LEFT_RIGHT) && /* Special case */
(CacheSlot(SC_LEFT_RIGHT) !=
(SetWord(inm(SC_RIGHT), 1) | SetWord(inm(SC_LEFT), 0))))
{
UncacheRegister(SC_LEFT_RIGHT);
xf86DrvMsg(pScreenInfo->scrnIndex, X_WARNING,
"SC_LEFT_RIGHT write cache disabled!\n");
}
if (RegisterIsCached(SC_TOP_BOTTOM) && /* Special case */
(CacheSlot(SC_TOP_BOTTOM) !=
(SetWord(inm(SC_BOTTOM), 1) | SetWord(inm(SC_TOP), 0))))
{
UncacheRegister(SC_TOP_BOTTOM);
xf86DrvMsg(pScreenInfo->scrnIndex, X_WARNING,
"SC_TOP_BOTTOM write cache disabled!\n");
}
TestRegisterCaching(DP_BKGD_CLR);
TestRegisterCaching(DP_FRGD_CLR);
TestRegisterCaching(DP_WRITE_MASK);
TestRegisterCaching(DP_MIX);
TestRegisterCaching(CLR_CMP_CLR);
TestRegisterCaching(CLR_CMP_MSK);
TestRegisterCaching(CLR_CMP_CNTL);
if (pATI->Block1Base)
{
TestRegisterCaching(OVERLAY_Y_X_START);
TestRegisterCaching(OVERLAY_Y_X_END);
TestRegisterCaching(OVERLAY_GRAPHICS_KEY_CLR);
TestRegisterCaching(OVERLAY_GRAPHICS_KEY_MSK);
TestRegisterCaching(OVERLAY_KEY_CNTL);
TestRegisterCaching(OVERLAY_SCALE_INC);
TestRegisterCaching(OVERLAY_SCALE_CNTL);
TestRegisterCaching(SCALER_HEIGHT_WIDTH);
TestRegisterCaching(SCALER_TEST);
TestRegisterCaching(VIDEO_FORMAT);
if (pATI->Chip < ATI_CHIP_264VTB)
{
TestRegisterCaching(BUF0_OFFSET);
TestRegisterCaching(BUF0_PITCH);
TestRegisterCaching(BUF1_OFFSET);
TestRegisterCaching(BUF1_PITCH);
}
else
{
TestRegisterCaching(SCALER_BUF0_OFFSET);
TestRegisterCaching(SCALER_BUF1_OFFSET);
TestRegisterCaching(SCALER_BUF_PITCH);
TestRegisterCaching(OVERLAY_EXCLUSIVE_HORZ);
TestRegisterCaching(OVERLAY_EXCLUSIVE_VERT);
if (pATI->Chip >= ATI_CHIP_264GTPRO)
{
TestRegisterCaching(SCALER_COLOUR_CNTL);
TestRegisterCaching(SCALER_H_COEFF0);
TestRegisterCaching(SCALER_H_COEFF1);
TestRegisterCaching(SCALER_H_COEFF2);
TestRegisterCaching(SCALER_H_COEFF3);
TestRegisterCaching(SCALER_H_COEFF4);
TestRegisterCaching(SCALER_BUF0_OFFSET_U);
TestRegisterCaching(SCALER_BUF0_OFFSET_V);
TestRegisterCaching(SCALER_BUF1_OFFSET_U);
TestRegisterCaching(SCALER_BUF1_OFFSET_V);
}
}
}
}
}
/*
* For VTB's and later, the first CPU read of the framebuffer will return
* zeroes, so do it here. This appears to be due to some kind of engine
* caching of framebuffer data I haven't found any way of disabling, or
* otherwise circumventing. Thanks to Mark Vojkovich for the suggestion.
*/
if (pATI->pXAAInfo)
pATI->pXAAInfo->NeedToSync = FALSE;
pATI = *(volatile ATIPtr *)pATI->pMemory;
}
DialogSpellChecker::DialogSpellChecker(agi::Context *context)
: wxDialog(context->parent, -1, _("Spell Checker"))
, context(context)
, spellchecker(SpellCheckerFactory::GetSpellChecker())
{
SetIcon(GETICON(spellcheck_toolbutton_16));
wxSizer *main_sizer = new wxBoxSizer(wxVERTICAL);
auto current_word_sizer = new wxFlexGridSizer(2, 5, 5);
main_sizer->Add(current_word_sizer, wxSizerFlags().Expand().Border(wxALL, 5));
wxSizer *bottom_sizer = new wxBoxSizer(wxHORIZONTAL);
main_sizer->Add(bottom_sizer, wxSizerFlags().Expand().Border(~wxTOP & wxALL, 5));
wxSizer *bottom_left_sizer = new wxBoxSizer(wxVERTICAL);
bottom_sizer->Add(bottom_left_sizer, wxSizerFlags().Expand().Border(wxRIGHT, 5));
wxSizer *actions_sizer = new wxBoxSizer(wxVERTICAL);
bottom_sizer->Add(actions_sizer, wxSizerFlags().Expand());
// Misspelled word and currently selected correction
current_word_sizer->AddGrowableCol(1, 1);
current_word_sizer->Add(new wxStaticText(this, -1, _("Misspelled word:")), 0, wxALIGN_CENTER_VERTICAL);
current_word_sizer->Add(orig_word = new wxTextCtrl(this, -1, "", wxDefaultPosition, wxDefaultSize, wxTE_READONLY), wxSizerFlags(1).Expand());
current_word_sizer->Add(new wxStaticText(this, -1, _("Replace with:")), 0, wxALIGN_CENTER_VERTICAL);
current_word_sizer->Add(replace_word = new wxTextCtrl(this, -1, ""), wxSizerFlags(1).Expand());
replace_word->Bind(wxEVT_TEXT, [=](wxCommandEvent&) {
remove_button->Enable(spellchecker->CanRemoveWord(from_wx(replace_word->GetValue())));
});
// List of suggested corrections
suggest_list = new wxListBox(this, -1, wxDefaultPosition, wxSize(300, 150));
suggest_list->Bind(wxEVT_LISTBOX, &DialogSpellChecker::OnChangeSuggestion, this);
suggest_list->Bind(wxEVT_LISTBOX_DCLICK, &DialogSpellChecker::OnReplace, this);
bottom_left_sizer->Add(suggest_list, wxSizerFlags(1).Expand());
// List of supported spellchecker languages
{
if (!spellchecker.get()) {
wxMessageBox("No spellchecker available.", "Error", wxOK | wxICON_ERROR | wxCENTER);
throw agi::UserCancelException("No spellchecker available");
}
dictionary_lang_codes = to_wx(spellchecker->GetLanguageList());
if (dictionary_lang_codes.empty()) {
wxMessageBox("No spellchecker dictionaries available.", "Error", wxOK | wxICON_ERROR | wxCENTER);
throw agi::UserCancelException("No spellchecker dictionaries available");
}
wxArrayString language_names(dictionary_lang_codes);
for (size_t i = 0; i < dictionary_lang_codes.size(); ++i) {
if (const wxLanguageInfo *info = wxLocale::FindLanguageInfo(dictionary_lang_codes[i]))
language_names[i] = info->Description;
}
language = new wxComboBox(this, -1, "", wxDefaultPosition, wxDefaultSize, language_names, wxCB_DROPDOWN | wxCB_READONLY);
wxString cur_lang = to_wx(OPT_GET("Tool/Spell Checker/Language")->GetString());
int cur_lang_index = dictionary_lang_codes.Index(cur_lang);
if (cur_lang_index == wxNOT_FOUND) cur_lang_index = dictionary_lang_codes.Index("en");
if (cur_lang_index == wxNOT_FOUND) cur_lang_index = dictionary_lang_codes.Index("en_US");
if (cur_lang_index == wxNOT_FOUND) cur_lang_index = 0;
language->SetSelection(cur_lang_index);
language->Bind(wxEVT_COMBOBOX, &DialogSpellChecker::OnChangeLanguage, this);
bottom_left_sizer->Add(language, wxSizerFlags().Expand().Border(wxTOP, 5));
}
{
wxSizerFlags button_flags = wxSizerFlags().Expand().Bottom().Border(wxBOTTOM, 5);
auto make_checkbox = [&](wxString const& text, const char *opt) {
auto checkbox = new wxCheckBox(this, -1, text);
actions_sizer->Add(checkbox, button_flags);
checkbox->SetValue(OPT_GET(opt)->GetBool());
checkbox->Bind(wxEVT_CHECKBOX,
[=](wxCommandEvent &evt) { OPT_SET(opt)->SetBool(!!evt.GetInt()); });
};
make_checkbox(_("&Skip Comments"), "Tool/Spell Checker/Skip Comments");
make_checkbox(_("Ignore &UPPERCASE words"), "Tool/Spell Checker/Skip Uppercase");
wxButton *button;
actions_sizer->Add(button = new wxButton(this, -1, _("&Replace")), button_flags);
button->Bind(wxEVT_BUTTON, &DialogSpellChecker::OnReplace, this);
actions_sizer->Add(button = new wxButton(this, -1, _("Replace &all")), button_flags);
button->Bind(wxEVT_BUTTON, [=](wxCommandEvent&) {
auto_replace[from_wx(orig_word->GetValue())] = from_wx(replace_word->GetValue());
Replace();
FindNext();
});
actions_sizer->Add(button = new wxButton(this, -1, _("&Ignore")), button_flags);
button->Bind(wxEVT_BUTTON, [=](wxCommandEvent&) { FindNext(); });
actions_sizer->Add(button = new wxButton(this, -1, _("Ignore a&ll")), button_flags);
button->Bind(wxEVT_BUTTON, [=](wxCommandEvent&) {
auto_ignore.insert(from_wx(orig_word->GetValue()));
FindNext();
});
actions_sizer->Add(add_button = new wxButton(this, -1, _("Add to &dictionary")), button_flags);
add_button->Bind(wxEVT_BUTTON, [=](wxCommandEvent&) {
spellchecker->AddWord(from_wx(orig_word->GetValue()));
FindNext();
});
actions_sizer->Add(remove_button = new wxButton(this, -1, _("Remove fro&m dictionary")), button_flags);
remove_button->Bind(wxEVT_BUTTON, [=](wxCommandEvent&) {
spellchecker->RemoveWord(from_wx(replace_word->GetValue()));
SetWord(from_wx(orig_word->GetValue()));
});
actions_sizer->Add(new HelpButton(this, "Spell Checker"), button_flags);
actions_sizer->Add(new wxButton(this, wxID_CANCEL), button_flags.Border(0));
}
SetSizerAndFit(main_sizer);
CenterOnParent();
if (FindNext())
Show();
}
void
Write::SetLBAT(uint16_t lbat)
{
LOG_NRM("Setting LBAT = 0x%04X", lbat);
SetWord(lbat, 15, 0);
}
void
Write::SetLBATM(uint16_t lbatm)
{
LOG_NRM("Setting LBATM = 0x%04X", lbatm);
SetWord(lbatm, 15, 1);
}
void
Write::SetNLB(uint16_t nlb)
{
LOG_NRM("Setting NLB = 0x%04X", nlb);
SetWord(nlb, 12, 0);
}
static int MakeRegex( DaoRegex *self, DString *ds, void *spatt,
int start, int end, int grouping )
{
DaoRgxItem *patt, *patt2, *split=NULL, *patts = self->items;
DaoRgxItem word = { PAT_NONE };
DaoRgxItem set = { PAT_NONE };
DCharState st = { 0, 1, 0 };
DCharState st2 = { 0, 1, 0 };
char *buf, *mbs = (char*) spatt;
int i, j, k, count=0, repeat=0, refgroup=0;
short type, gid = self->indexed >0 ? self->indexed + 1E4 : self->group;
int alts = DString_BalancedChar( ds, '|', '(', ')', '%', start, end, 1 );
daoint pos, pos2;
int chi, chi2;
if( alts >0 || grouping >0 ){
split = PushRegex( self, PAT_SPLIT );
split->gid = gid;
count = self->count;
}
self->indexed = 0;
word.next = set.next = 1;
word.jump = set.jump = 0;
for(i=start; i<end; i++){
int verbatim = 0;
chi = mbs[i];
chi2 = (i+1) >= end ? 0 : mbs[i+1];
type = 0;
k = i;
/* space chars are ignored, to avoid this, write as [ ][\t][\n] */
if( isspace( chi ) ){
if( word.type == PAT_WORD ) PushWord( self, & word );
continue;
}
if( chi == '%' ){
if( i+1 < end ) chi = mbs[i+1];
switch( chi ){
case 's': case 'S': case 'k': case 'K': case 'p': case 'P':
case 'c': case 'C': case 'a': case 'A': case 'w': case 'W':
case 'e': case 'E': case 'd': case 'D': case 'x': case 'X':
type = chi;
break;
case 't':
type = PAT_WORD;
SetWord( self, & word, i, L'\t' );
break;
case 'n':
type = PAT_WORD;
SetWord( self, & word, i, L'\n' );
break;
case '1': case '2': case '3': case '4': case '5':
case '6': case '7': case '8': case '9':
j = ScanInteger( & refgroup, spatt, i+1, end );
type = PAT_BACKREF;
i += j-1;
break;
case 'b':
type = PAT_NONE;
if( i+3 < end ){
st = DString_DecodeChar( mbs + i + 2, mbs + end );
st2 = DString_DecodeChar( mbs + i + 2 + st.width, mbs + end );
chi = st.value;
chi2 = st2.value;
if( ! iswspace( chi ) && ! iswspace( chi2 ) ){
set.type = type = PAT_PAIR;
set.word = i + 1;
set.length = st.width + st2.width;
buf = self->wordbuf + set.word;
memcpy( buf, mbs + i + 2, set.length * sizeof(char) );
i += set.length;
}
}
break;
case 'B':
type = PAT_NONE;
chi = mbs[i+2];
if( chi == '{' ){
pos = DString_BalancedChar( ds, '}','{','}','%', i+3, end, 0 );
chi = 0;
pos2 = DAO_NULLPOS;
if( pos != DAO_NULLPOS ){
chi = mbs[pos+1];
pos2 = DString_BalancedChar( ds, '}','{','}','%', pos+2, end, 0 );
}
if( chi == '{' && pos2 != DAO_NULLPOS ){
short count2, count3;
count2 = self->count;
patt = PushRegex( self, PAT_PATPAIR );
PushRegex( self, PAT_BEGIN );
MakeRegex( self, ds, spatt, i+3, pos, 0 );
PushRegex( self, PAT_STOP );
count3 = self->count;
PushRegex( self, PAT_BEGIN );
MakeRegex( self, ds, spatt, pos+2, pos2, 0 );
PushRegex( self, PAT_STOP );
patt->next = self->count - count2;
patt->length = count3 - count2;
i = pos2;
i += SetRepeat( & patt->min, & patt->max, spatt, ds, i+1, end );
continue;
}
}
break;
default :
type = (i+1 < end) ? PAT_WORD : PAT_NONE;
SetWord( self, & word, i, chi );
break;
}
i ++;
}else if( chi == '{' && chi2 == '{' ){ /* {{text}} */
verbatim = 1;
type = PAT_WORD;
i += 2;
while( i < end ){
chi = mbs[i];
i += 1;
/* printf( "%c\n", chi ); */
if( chi == '}' ) break;
SetWord( self, & word, i-1, chi );
}
chi = 0;
k = i - 1;
if( i < end ){
chi = mbs[i];
k = i;
}
if( chi != '}' ) type = PAT_NONE;
}else if( chi == '(' ){
if( word.type == PAT_WORD ) PushWord( self, & word );
pos = DString_BalancedChar( ds, ')', '(', ')', '%', i+1, end, 0 );
if( pos != DAO_NULLPOS ){
self->group ++;
MakeRegex( self, ds, spatt, i+1, pos, 1 );
i = pos;
continue;
}
}else if( chi == '[' ){
pos = DString_BalancedChar( ds, ']', 0, 0, '%', i+1, end, 0 );
pos2 = DString_BalancedChar( ds, '[', '[', ']', '%', i+1, end, 0 );
if( pos == i+2 && pos2 == DAO_NULLPOS ){
type = PAT_WORD;
i ++;
chi = mbs[i];
SetWord( self, & word, i, chi );
i = pos;
}else if( pos != DAO_NULLPOS && pos2 == DAO_NULLPOS ){
type = PAT_SET;
set.type = PAT_SET;
set.length = pos - i - 1;
set.word = i + 1;
buf = self->wordbuf + set.word;
memcpy( buf, mbs + i + 1, set.length * sizeof(char) );
buf[ set.length ] = 0;
i = pos;
}else{
type = PAT_NONE;
}
}else if( chi == '<' ){
int k;
if( word.type == PAT_WORD ) PushWord( self, & word );
j = SkipSpace( spatt, i+1, end ); i += j+1;
chi = mbs[i];
k = i;
if( isdigit( chi ) ){
j = ScanInteger( & k, spatt, i, end ); i += j;
self->indexed = k;
}else if( islower( chi ) ){
if( strncmp( mbs + i, "min", 3 ) ==0 ){
self->config |= PAT_CONFIG_MIN;
i += 3;
}
}else{
for(; i<end; i++){
chi = mbs[i];
if( chi == 'I' ){
self->config |= PAT_CONFIG_CASEINS;
}else if( chi == 'C' ){
self->config &= ~ PAT_CONFIG_CASEINS;
}else{
break;
}
}
}
j = SkipSpace( spatt, i, end ); i += j;
chi = mbs[i];
if( chi == '>' && k != i ){
continue;
}else{
type = PAT_NONE;
}
}else if( chi == '.' ){
type = PAT_ANY;
}else if( chi == '|' ){
if( word.type == PAT_WORD ) PushWord( self, & word );
patt2 = PushRegex( self, PAT_JOIN );
patt = PushRegex( self, PAT_SPLIT );
patt->gid = patt2->gid = gid;
if( split ) split->jump = patt - split;
split = patt;
continue;
}else if( chi == '^' ){
type = PAT_START;
}else if( chi == '$' ){
type = PAT_END;
}else if( chi == '&' ){
type = PAT_WBORDER;
}else{
type = PAT_NONE;
switch( chi ){
case ']': case ')': case '{': case '}': case '|':
case '-': case '?': case '*': case '+': break;
default : type = PAT_WORD; break;
}
if( type == PAT_WORD ) SetWord( self, & word, i, chi );
}
if( type != PAT_WORD && word.type == PAT_WORD ) PushWord( self, & word );
patt = patts + self->count;
patt->type = type;
patt->gid = 0;
patt->min = patt->max = 1;
patt->next = 1;
patt->jump = 0;
if( type == PAT_BACKREF ) patt->gid = refgroup;
if( type == PAT_NONE ) patt->length = k + 1; /* store the error position */
if( word.type == PAT_WORD ){
patt->word = word.word;
patt->length = word.length;
}else if( set.type == PAT_SET || set.type == PAT_PAIR ){
patt->word = set.word;
patt->length = set.length;
set.type = PAT_NONE;
}
repeat = SetRepeat( & patt->min, & patt->max, spatt, ds, i+1, end );
i += repeat;
if( patt->type == PAT_WORD && repeat && verbatim == 0 && patt->length > 1 ){
/* Handle single character repetition: */
int offset = patt->word;
int length = patt->length;
int min = patt->min;
int max = patt->max;
self->count += 1;
patt->min = patt->max = 1;
patt->length -= 1;
patt = PushRegex( self, PAT_WORD );
patt->min = min;
patt->max = max;
patt->word = offset + length - 1;
patt->length = 1;
self->count -= 1;
}
if( patt->type != PAT_WORD || repeat ){
patt2 = NULL;
if( self->count ) patt2 = patts + (self->count-1);
if( patt2 && RegexCompare( self, patt, patt2 ) ){
patt2->min += patt->min;
if( patt2->max >=0 && patt->max >=0 ){
patt2->max += patt->max;
}else{
patt2->max = -1;
}
}else{
patt->config = self->config;
self->count ++;
}
word.type = PAT_NONE;
}
}
if( word.type == PAT_WORD ) PushWord( self, & word );
if( alts >0 || grouping >0 ){
patt = PushRegex( self, PAT_JOIN );
patt->gid = gid;
for(j=count; j<self->count; j++){
patt = patts + j;
if( patt->type == PAT_JOIN && patt->gid == gid )
patt->next = self->count - j;
if( patt->gid == gid && j+1 < self->count ){
/* for PAT_SPLIT added for | in groups,
* required for calculate matching length */
if( patt->type == PAT_SPLIT ) patt->gid = 0;
}
}
split->length = self->count - count;
}
return self->count;
}
