wxString TagEntry::NameFromTyperef(wxString& templateInitList, bool nameIncludeTemplate)
{
wxString typeref = GetTyperef();
if(typeref.IsEmpty() == false) {
wxString name = typeref.AfterFirst(wxT(':'));
return name;
}
// incase our entry is a typedef, and it is not marked as typeref,
// try to get the real name from the pattern
if(GetKind() == wxT("typedef")) {
wxString pat(GetPattern());
if(!GetPattern().Contains(wxT("typedef"))) {
// The pattern does not contain 'typedef' however this *is* a typedef
// try to see if this is a macro
pat.StartsWith(wxT("/^"), &pat);
pat.Trim().Trim(false);
// we take the first token
CppScanner scanner;
scanner.SetText(pat.To8BitData());
int type = scanner.yylex();
if(type == IDENTIFIER) {
wxString token = wxString::From8BitData(scanner.YYText());
PPToken tok = TagsManagerST::Get()->GetDatabase()->GetMacro(token);
if(tok.flags & PPToken::IsValid) {
// we found a match!
if(tok.flags & PPToken::IsFunctionLike) {
wxArrayString argList;
if(GetMacroArgList(scanner, argList)) {
tok.expandOnce(argList);
}
}
pat = tok.replacement;
pat << wxT(";");
// Remove double spaces
while(pat.Replace(wxT(" "), wxT(" "))) {
}
}
}
}
wxString name;
if(TypedefFromPattern(pat, GetName(), name, templateInitList, nameIncludeTemplate)) return name;
}
return wxEmptyString;
}
static BOOL GetValue(PEDIT_FIELD pCtrl, UINT32 *pValue)
{
EDIT_PATTERN Pattern;
UINT32 value,dval;
GetPattern(pCtrl, &Pattern);
if('p' == Pattern.bTag || 's' == Pattern.bTag || 'm' == Pattern.bTag)
return FALSE;
if('i' == Pattern.bTag)
*pValue = ConvertIP2int(pCtrl->pString);
else
*pValue = ComUniStr2Int(pCtrl->pString);
if((UINT8)(pCtrl->pString[6]>>8)=='P')
setTimeMode(1); //ui set am/pm, not decide by value. 0 for am, 1 for pm
if('r' == Pattern.bTag)
{
CHECK_RANGE:
value = CheckRangeValue(*pValue, Pattern.r.nMin, Pattern.r.nMax, FALSE);
if(value != *pValue)
{
value = pCtrl->valbak;
*pValue = value;
dval = OSD_GetEditFieldDefaultVal(pCtrl);
if(dval!=FORCE_TO_VALBAK)
goto CHECK_RANGE;
}
}
return TRUE;
}
int TagEntry::Store(wxSQLite3Statement& insertPerepareStmnt)
{
// If this node is a dummy, (IsOk() == false) we dont insert it to database
if( !IsOk() )
return TagOk;
try
{
// see TagsDatabase::GetInsertOneStatement() for the order of binding
insertPerepareStmnt.Bind(1, GetParentId());
insertPerepareStmnt.Bind(2, GetName());
insertPerepareStmnt.Bind(3, GetFile());
insertPerepareStmnt.Bind(4, GetLine());
insertPerepareStmnt.Bind(5, GetKind());
insertPerepareStmnt.Bind(6, GetAccess());
insertPerepareStmnt.Bind(7, GetSignature());
insertPerepareStmnt.Bind(8, GetPattern());
insertPerepareStmnt.Bind(9, GetParent());
insertPerepareStmnt.Bind(10, GetInherits());
insertPerepareStmnt.Bind(11, GetPath());
insertPerepareStmnt.Bind(12, GetTyperef());
insertPerepareStmnt.Bind(13, GetScope());
insertPerepareStmnt.ExecuteUpdate();
insertPerepareStmnt.Reset();
}
catch(wxSQLite3Exception& exc)
{
if(exc.ErrorCodeAsString(exc.GetErrorCode()) == wxT("SQLITE_CONSTRAINT"))
return TagExist;
wxLogMessage(exc.GetMessage());
return TagError;
}
return TagOk;
}
int TagEntry::Update(wxSQLite3Statement& updatePerepareStmnt)
{
// If this node is a dummy, (IsOk() == false) we dont update it to database
if( !IsOk() )
return TagOk;
try
{
// see TagsDatabase::GetUpdateOneStatement() function for the order of binding
updatePerepareStmnt.Bind(1, GetParentId());
updatePerepareStmnt.Bind(2, GetName());
updatePerepareStmnt.Bind(3, GetFile());
updatePerepareStmnt.Bind(4, GetLine());
updatePerepareStmnt.Bind(5, GetAccess());
updatePerepareStmnt.Bind(6, GetPattern());
updatePerepareStmnt.Bind(7, GetParent());
updatePerepareStmnt.Bind(8, GetInherits());
updatePerepareStmnt.Bind(9, GetTyperef());
updatePerepareStmnt.Bind(10, GetScope());
updatePerepareStmnt.Bind(11, GetKind());
updatePerepareStmnt.Bind(12, GetSignature());
updatePerepareStmnt.Bind(13, GetPath());
updatePerepareStmnt.ExecuteUpdate();
updatePerepareStmnt.Reset();
}
catch(wxSQLite3Exception& exc)
{
wxLogMessage(exc.GetMessage());
return TagError;
}
return TagOk;
}
size_t DSA_controller::generatePattern(int N_circuits, int N_robots)
{
string ID = GetId();
string ID_number;
for(size_t i = 0; i < ID.size(); i++) {
if(ID[i] >= '0' && ID[i] <= '9') {
ID_number += ID[i];
}
}
size_t RobotNumber = stoi(ID_number);
vector<string> paths;
string ith_robot_path;
for (int i_robot = 1; i_robot <= N_robots; i_robot++)
{
// cout << "inside for 1" << endl;
for (int i_circuit = 0; i_circuit < N_circuits; i_circuit++)
{
int n_steps_north = calcDistanceToTravel(i_robot, i_circuit, N_robots, 'N');
for (int j = 0; j < n_steps_north; j++)
{
//ith_robot_path.push_back('N');
ith_robot_path += 'N';
}
int n_steps_east = calcDistanceToTravel(i_robot, i_circuit, N_robots, 'E');
for (int j = 0; j < n_steps_east; j++)
{
//ith_robot_path.push_back('E');
ith_robot_path += 'E';
}
int n_steps_south = calcDistanceToTravel(i_robot, i_circuit, N_robots, 'S');
for (int j = 0; j < n_steps_south; j++)
{
//ith_robot_path.push_back('S');
ith_robot_path += 'S';
}
int n_steps_west = calcDistanceToTravel(i_robot, i_circuit, N_robots, 'W');
for (int j = 0; j < n_steps_west; j++)
{
//ith_robot_path.push_back('W');
ith_robot_path += 'W';
}
}
paths.push_back(ith_robot_path);
ith_robot_path.clear();
}
//pattern = ith_robot_path;
GetPattern(paths[RobotNumber]);
return RobotNumber;
}
void CompilerPatternDlg::OnSubmit(wxCommandEvent& event)
{
if(GetPattern().Trim().IsEmpty() || GetFileIndex().Trim().IsEmpty() || GetLineIndex().Trim().IsEmpty()) {
wxMessageBox(_("Please fill all the fields"), _("CodeLite"), wxOK | wxICON_INFORMATION, this);
return;
}
EndModal(wxID_OK);
}
bool TextInlineFormat_Underline::CompareAndUpdateProperties(const std::wstring& pattern)
{
if (_wcsicmp(GetPattern().c_str(), pattern.c_str()) != 0)
{
SetPattern(pattern);
return true;
}
return false;
}
bool TextInlineFormat_Color::CompareAndUpdateProperties(const std::wstring& pattern, const Gdiplus::Color& color)
{
if (_wcsicmp(GetPattern().c_str(), pattern.c_str()) != 0 || m_Color.GetValue() != color.GetValue())
{
SetPattern(pattern);
m_Color = color;
return true;
}
return false;
}
void BitmapGraphic::Write (ostream& out) {
Catalog* catalog = unidraw->GetCatalog();
catalog->WriteBgFilled(BgFilled(), out);
catalog->WriteBrush(GetBrush(), out);
catalog->WriteColor(GetFgColor(), out);
catalog->WriteColor(GetBgColor(), out);
catalog->WriteFont(GetFont(), out);
catalog->WritePattern(GetPattern(), out);
catalog->WriteTransformer(GetTransformer(), out);
catalog->WriteString(_fg_name, out);
}
wxString TagEntry::GetPatternClean() const
{
wxString p = GetPattern();
p.Trim();
if(p.StartsWith(wxT("/^"))) {
p.Replace(wxT("/^"), wxT(""));
}
if(p.EndsWith(wxT("$/"))) {
p.Replace(wxT("$/"), wxT(""));
}
return p;
}
bool TextInlineFormat_Typography::CompareAndUpdateProperties(
const std::wstring& pattern, const DWRITE_FONT_FEATURE_TAG& tag, UINT32 parameter)
{
if (_wcsicmp(GetPattern().c_str(), pattern.c_str()) != 0 || m_Tag != tag || m_Parameter != parameter)
{
SetPattern(pattern);
m_Tag = tag;
m_Parameter = parameter;
return true;
}
return false;
}
bool TextInlineFormat_Shadow::CompareAndUpdateProperties(const std::wstring& pattern, const FLOAT& blur,
const D2D1_POINT_2F& offset, const Gdiplus::Color& color)
{
if (_wcsicmp(GetPattern().c_str(), pattern.c_str()) != 0 || m_Color.GetValue() != color.GetValue())
{
SetPattern(pattern);
m_Offset = offset;
m_Color = color;
return true;
}
return false;
}
void TagEntry::Print()
{
std::cout << "======================================" << std::endl;
std::cout << "Name:\t\t" << GetName() << std::endl;
std::cout << "File:\t\t" << GetFile() << std::endl;
std::cout << "Line:\t\t" << GetLine() << std::endl;
std::cout << "Pattern\t\t" << GetPattern() << std::endl;
std::cout << "Kind:\t\t" << GetKind() << std::endl;
std::cout << "Parent:\t\t" << GetParent() << std::endl;
std::cout << " ---- Ext fields: ---- " << std::endl;
std::map<wxString, wxString>::const_iterator iter = m_extFields.begin();
for(; iter != m_extFields.end(); iter++)
std::cout << iter->first << ":\t\t" << iter->second << std::endl;
std::cout << "======================================" << std::endl;
}
wxString TagEntry::NameFromTyperef(wxString &templateInitList)
{
wxString typeref = GetTyperef();
if ( typeref.IsEmpty() == false ) {
wxString name = typeref.AfterFirst(wxT(':'));
return name;
}
// incase our entry is a typedef, and it is not marked as typeref,
// try to get the real name from the pattern
if ( GetKind() == wxT("typedef")) {
wxString name;
if (TypedefFromPattern(GetPattern(), GetName(),name, templateInitList))
return name;
}
return wxEmptyString;
}
void QElipseItem::compile(QSqlDatabase &db, int nSceneId,int &count,int index)
{
count++;
//QBasicGraphicsItem::compile(db, nSceneId, count, index);
QSqlQuery sqlquery(db);
sqlquery.prepare("INSERT INTO polygon(nItemId ,nSceneId,ePolygonClass,eLineType ,nLineWidth,nLineColor,"
"eStyle,nBackColor,nForeColor,nAlpha,nPointX,nPointY,nWidth,nHeight,nRadius,eCornerType,"
"nZvalue,nCollidindId)"
"VALUES (:nItemId,:nSceneId,:ePolygonClass ,:eLineType ,:nLineWidth,:nLineColor,:eStyle,"
":nBackColor,:nForeColor,:nAlpha,:nPointX,:nPointY,:nWidth,:nHeight,:nRadius,:eCornerType,"
":nZvalue,:nCollidindId)");
sqlquery.bindValue(":nItemId",QVariant(count));// 表 id
sqlquery.bindValue(":nSceneId",QVariant(nSceneId));// 所在场景 id
sqlquery.bindValue(":ePolygonClass",QVariant(1)); //1 代表类型为圆
sqlquery.bindValue(":eLineType",QVariant(nLineType+1));// 线形
sqlquery.bindValue(":nLineWidth",QVariant(GetLineWidth()));// 线宽
sqlquery.bindValue(":nLineColor",QVariant(ColorToInt(GetLineColor()))); //颜色
sqlquery.bindValue(":eStyle",QVariant(GetPattern()+1));// 样式
sqlquery.bindValue(":nBackColor",QVariant(ColorToInt(GetBackColor()))); //背景色
sqlquery.bindValue(":nForeColor",QVariant(ColorToInt(GetFrontColor()))); //前景色
sqlquery.bindValue(":nAlpha",QVariant(GetAlpha()));// 透明度
QRect rect = this->sceneBoundingRect().toRect();
sqlquery.bindValue(":nStartX",QVariant(rect.x()));//x
sqlquery.bindValue(":nStartY",QVariant(rect.y()));//y
sqlquery.bindValue(":nWidth",QVariant(rect.width()));//w
sqlquery.bindValue(":nHeight",QVariant(rect.height()));//h
sqlquery.bindValue(":nZvalue",QVariant(zValue()));//层次
sqlquery.bindValue(":nCollidindId",QVariant(index));//碰撞ID
bool result = false;
result = sqlquery.exec();
qDebug() << "insert Elipse table :"<<result;
SamDrawScene *pScene = dynamic_cast<SamDrawScene *>(scene());
if(pScene && pScene->nIsSceneOrWindow == 2)
{
//是自定义键盘的item
//先新建键盘——item关联表 item表在派生类中创建
//QSqlQuery sqlquery(db);
sqlquery.prepare("INSERT INTO kbAndItem(nKeyBoardId , nItemId ,nId,nItemTableType ) "
"VALUES (:nKeyBoardId ,:nItemId ,:nId,:nItemTableType)");
sqlquery.bindValue(":nKeyBoardId",QVariant(nSceneId));
sqlquery.bindValue(":nItemId",QVariant(count));
sqlquery.bindValue(":nId",QVariant(id()));
sqlquery.bindValue(":nItemTableType",QVariant((int)SAM_DRAW_OBJECT_ELIPSE));
bool result = false;
result = sqlquery.exec();
qDebug() << "insert kbAndItem table :"<<result;
}
if(pScene && pScene->nIsSceneOrWindow != 2)
{
//窗口或者场景item
//先新建键盘——item关联表
//item表在派生类中创建
//QSqlQuery sqlquery(db);
sqlquery.prepare("INSERT INTO sceneAndItem(nSceneId,nItemId,nId,nItemTableType)"
"VALUES(:nSceneId,:nItemId,:nId,:nItemTableType)");
sqlquery.bindValue(":nSceneId",QVariant(nSceneId));
sqlquery.bindValue(":nItemId",QVariant(count));
sqlquery.bindValue(":nId",QVariant(id()));
//int t = this->GroupType();
sqlquery.bindValue(":nItemTableType",QVariant((int)SAM_DRAW_OBJECT_ELIPSE));
bool result = false;
result = sqlquery.exec();
qDebug() << "insert sceneAndItem table :"<<result;
}
}
pascal PatHandle SafeGetPattern(short patternID)
{
StAcroResourceContext resContext;
return GetPattern(patternID);
}
wxString TagEntry::FormatComment()
{
if(m_isCommentForamtted) return m_formattedComment;
m_isCommentForamtted = true;
m_formattedComment.Clear();
// Send the plugins an event requesting tooltip for this tag
if(IsMethod()) {
if(IsConstructor())
m_formattedComment << wxT("<b>[Constructor]</b>\n");
else if(IsDestructor())
m_formattedComment << wxT("<b>[Destructor]</b>\n");
TagEntryPtr p(new TagEntry(*this));
m_formattedComment << wxT("<code>")
<< TagsManagerST::Get()->FormatFunction(p, FunctionFormat_WithVirtual | FunctionFormat_Arg_Per_Line)
<< wxT("</code>\n");
m_formattedComment.Replace(GetName(), wxT("<b>") + GetName() + wxT("</b>"));
} else if(IsClass()) {
m_formattedComment << wxT("<b>Kind:</b> ");
m_formattedComment << GetKind() << "\n";
if(GetInheritsAsString().IsEmpty() == false) {
m_formattedComment << wxT("<b>Inherits:</b> ");
m_formattedComment << GetInheritsAsString() << wxT("\n");
}
} else if(IsMacro() || IsTypedef() || IsContainer() || GetKind() == wxT("member") ||
GetKind() == wxT("variable")) {
m_formattedComment << wxT("<b>Kind:</b> ");
m_formattedComment << GetKind() << "\n";
m_formattedComment << wxT("<b>Match Pattern:</b> ");
// Prettify the match pattern
wxString matchPattern(GetPattern());
matchPattern.Trim().Trim(false);
if(matchPattern.StartsWith(wxT("/^"))) {
matchPattern.Replace(wxT("/^"), wxT(""));
}
if(matchPattern.EndsWith(wxT("$/"))) {
matchPattern.Replace(wxT("$/"), wxT(""));
}
matchPattern.Replace(wxT("\t"), wxT(" "));
while(matchPattern.Replace(wxT(" "), wxT(" "))) {
}
matchPattern.Trim().Trim(false);
// BUG#3082954: limit the size of the 'match pattern' to a reasonable size (200 chars)
matchPattern = TagsManagerST::Get()->WrapLines(matchPattern);
matchPattern.Replace(GetName(), wxT("<b>") + GetName() + wxT("</b>"));
m_formattedComment << wxT("<code>") << matchPattern << wxT("</code>\n");
}
// Add comment section
wxString tagComment;
if(!GetFile().IsEmpty()) {
CommentParseResult comments;
::ParseComments(GetFile().mb_str(wxConvUTF8).data(), comments);
// search for comment in the current line, the line above it and 2 above it
// use the first match we got
for(size_t i = 0; i < 3; i++) {
wxString comment = comments.getCommentForLine(GetLine()-i);
if(!comment.IsEmpty()) {
SetComment(comment);
break;
}
}
}
if(!GetComment().IsEmpty()) {
wxString theComment;
theComment = GetComment();
theComment = TagsManagerST::Get()->WrapLines(theComment);
theComment.Trim(false);
wxString tagComment = wxString::Format(wxT("%s\n"), theComment.c_str());
if(m_formattedComment.IsEmpty() == false) {
m_formattedComment.Trim().Trim(false);
m_formattedComment << wxT("\n<hr>");
}
m_formattedComment << tagComment;
}
// Update all "doxy" comments and surround them with <green> tags
static wxRegEx reDoxyParam("([@\\\\]{1}param)[ \t]+([_a-z][a-z0-9_]*)?", wxRE_DEFAULT | wxRE_ICASE);
static wxRegEx reDoxyBrief("([@\\\\]{1}(brief|details))[ \t]*", wxRE_DEFAULT | wxRE_ICASE);
static wxRegEx reDoxyThrow("([@\\\\]{1}(throw|throws))[ \t]*", wxRE_DEFAULT | wxRE_ICASE);
static wxRegEx reDoxyReturn("([@\\\\]{1}(return|retval|returns))[ \t]*", wxRE_DEFAULT | wxRE_ICASE);
static wxRegEx reDoxyToDo("([@\\\\]{1}todo)[ \t]*", wxRE_DEFAULT | wxRE_ICASE);
static wxRegEx reDoxyRemark("([@\\\\]{1}(remarks|remark))[ \t]*", wxRE_DEFAULT | wxRE_ICASE);
static wxRegEx reDate("([@\\\\]{1}date)[ \t]*", wxRE_DEFAULT | wxRE_ICASE);
static wxRegEx reFN("([@\\\\]{1}fn)[ \t]*", wxRE_DEFAULT | wxRE_ICASE);
if(reDoxyParam.IsValid() && reDoxyParam.Matches(m_formattedComment)) {
reDoxyParam.ReplaceAll(&m_formattedComment, "\n<b>Parameter</b>\n<i>\\2</i>");
}
if(reDoxyBrief.IsValid() && reDoxyBrief.Matches(m_formattedComment)) {
reDoxyBrief.ReplaceAll(&m_formattedComment, "");
}
if(reDoxyThrow.IsValid() && reDoxyThrow.Matches(m_formattedComment)) {
reDoxyThrow.ReplaceAll(&m_formattedComment, "\n<b>Throws</b>\n");
}
if(reDoxyReturn.IsValid() && reDoxyReturn.Matches(m_formattedComment)) {
reDoxyReturn.ReplaceAll(&m_formattedComment, "\n<b>Returns</b>\n");
}
if(reDoxyToDo.IsValid() && reDoxyToDo.Matches(m_formattedComment)) {
reDoxyToDo.ReplaceAll(&m_formattedComment, "\n<b>TODO</b>\n");
}
if(reDoxyRemark.IsValid() && reDoxyRemark.Matches(m_formattedComment)) {
reDoxyRemark.ReplaceAll(&m_formattedComment, "\n ");
}
if(reDate.IsValid() && reDate.Matches(m_formattedComment)) {
reDate.ReplaceAll(&m_formattedComment, "<b>Date</b> ");
}
if(reFN.IsValid() && reFN.Matches(m_formattedComment)) {
size_t fnStart, fnLen, fnEnd;
if(reFN.GetMatch(&fnStart, &fnLen)) {
fnEnd = m_formattedComment.find('\n', fnStart);
if(fnEnd != wxString::npos) {
// remove the string from fnStart -> fnEnd (including ther terminating \n)
m_formattedComment.Remove(fnStart, (fnEnd - fnStart) + 1);
}
}
}
// if nothing to display skip this
m_formattedComment.Trim().Trim(false);
return m_formattedComment;
}
//this function do half a job -
//parses rule you've supplied and
//calls AddTag every time, new tag has been parsed.
//Well, the rule can start from any character
BOOL COXRegExpression::Parse(CString& sString, int* pnNumber/*=NULL*/)
{
int nType = OX_REGEXP_TAG_COMMON_CHAR;
CString sValue;
CString sNumber;
int nNumber=0;
if (!pnNumber)
pnNumber=&nNumber;
int nMin=0;
int nMax=0;
if (sString.IsEmpty() || sString.GetLength()<=*pnNumber)
return FALSE;
//main loop
while (sString.GetLength()>*pnNumber)
{
TCHAR ch=sString.GetAt(*pnNumber);
(*pnNumber)++;
switch (nType)
{
case OX_REGEXP_TAG_COMMON_CHAR:
switch (ch)
{
case TEXT('\\'):
{
int nRet=GetSpecialChar(sString, pnNumber, &ch);
if (!nRet)
{
(*pnNumber)--;
return FALSE;
}
if (nRet==OX_REGEXP_TAG_REFERENCE_BACK)
{
CString sPattern;
int nNumber=(int) ch;
if (GetPattern(nNumber, sPattern))
sValue+=sPattern;
else
{
(*pnNumber)--;
SetError(OX_REGEXP_ERROR_NO_REFERENCE);
return FALSE;
}
continue;
}
if (nRet==OX_REGEXP_TAG_COMMON_CHAR)
{
sValue+=ch;
continue;
}
if (!sValue.IsEmpty())
AddTag(OX_REGEXP_TAG_COMMON_CHAR,&sValue);
switch (nRet)
{
case OX_REGEXP_TAG_DIGIT:
case OX_REGEXP_TAG_NON_DIGIT:
case OX_REGEXP_TAG_WHITESPACE:
case OX_REGEXP_TAG_NON_WHITESPACE:
case OX_REGEXP_TAG_ANY_WORD:
case OX_REGEXP_TAG_ANY_NON_WORD:
nType=nRet;
sValue="";
continue;
default:
AddTag(nRet, NULL);
sValue="";
continue;
}
}
break;
case TEXT('^'):
if (!sValue.IsEmpty())
AddTag(OX_REGEXP_TAG_COMMON_CHAR,&sValue);
AddTag(OX_REGEXP_TAG_BEGINING_OF_THE_LINE,NULL);
sValue="";
break;
case TEXT('$'):
if (!sValue.IsEmpty())
AddTag(OX_REGEXP_TAG_COMMON_CHAR,&sValue);
AddTag(OX_REGEXP_TAG_END_OF_THE_LINE,NULL);
sValue="";
break;
case TEXT('*'):
case TEXT('?'):
case TEXT('+'):
if (sValue.IsEmpty())
{
(*pnNumber)--;
SetError(OX_REGEXP_ERROR_MUST_CHAR_BEFORE);
return FALSE;
}
switch(ch)
{
case TEXT('*'):
//nType=OX_REGEXP_TAG_CHAR_ZERO_OR_MORE;
nMin=0;
nMax=-1;
break;
case TEXT('+'):
//nType=OX_REGEXP_TAG_CHAR_ONE_OR_MORE;
nMin=1;
nMax=-1;
break;
case TEXT('?'):
//nType=OX_REGEXP_TAG_CHAR_ZERO_OR_ONE;
nMin=0;
nMax=1;
break;
}
ch=sValue.GetAt(sValue.GetLength()-1);
sValue=(sValue.GetLength()==1)?
_T(""):sValue.Left(sValue.GetLength()-1);
if (!sValue.IsEmpty())
{
AddTag(OX_REGEXP_TAG_COMMON_CHAR,&sValue);
}
sValue=ch;
AddTag(OX_REGEXP_TAG_COMMON_CHAR,&sValue, nMin, nMax);
sValue="";
nType=OX_REGEXP_TAG_COMMON_CHAR;
break;
case TEXT('.'):
if (!sValue.IsEmpty())
{
AddTag(OX_REGEXP_TAG_COMMON_CHAR,&sValue);
}
nType=OX_REGEXP_TAG_CHAR_NOT_NEW_LINE;
sValue="";
break;
case TEXT('('):
if (!sValue.IsEmpty())
{
AddTag(OX_REGEXP_TAG_COMMON_CHAR,&sValue);
}
sValue="";
nType=OX_REGEXP_TAG_PATTERN;
break;
case TEXT(')'):
case TEXT(']'):
case TEXT('}'):
{
(*pnNumber)--;
SetError(OX_REGEXP_ERROR_UNEXPECTED_SPECCHAR);
return FALSE;
}
case TEXT('|'):
if (sValue.IsEmpty())
{
(*pnNumber)--;
SetError(OX_REGEXP_ERROR_MUST_CHAR_BEFORE);
return FALSE;
}
ch=sValue.GetAt(sValue.GetLength()-1);
sValue=(sValue.IsEmpty())?_T(""):sValue.Left(
sValue.GetLength()-1);
if (!sValue.IsEmpty())
AddTag(OX_REGEXP_TAG_COMMON_CHAR,&sValue);
sValue=ch;
nType=OX_REGEXP_TAG_CHARS_EITHER;
break;
case TEXT('{'):
{
if (sValue.IsEmpty())
{
(*pnNumber)--;
SetError(OX_REGEXP_ERROR_MUST_CHAR_BEFORE);
return FALSE;
}
ch=sValue.GetAt(sValue.GetLength()-1);
sValue=(sValue.IsEmpty())?_T(""):sValue.Left(
sValue.GetLength()-1);
if (!sValue.IsEmpty())
AddTag(OX_REGEXP_TAG_COMMON_CHAR,&sValue);
sValue=ch;
int nMin, nMax;
int nRet=GetMinMaxCount(sString,
pnNumber, &nMin, &nMax);
if (!nRet)
{
(*pnNumber)--;
return FALSE;
}
if (nRet==OX_REGEXP_TAG_CHARS_EXACTLY)
{
if (nMin)
{
for (int n=1;n<nMin;n++)
sValue+=sValue.Right(1);
AddTag(OX_REGEXP_TAG_COMMON_CHAR, &sValue);
}
}
else
AddTag(nRet,&sValue, nMin, nMax);
sValue="";
}
break;
case TEXT('['):
if (!sValue.IsEmpty())
AddTag(OX_REGEXP_TAG_COMMON_CHAR,&sValue);
sValue="";
nType=OX_REGEXP_TAG_CHARSET;
break;
case TEXT('/'):
if (!GetAsciiChar(sString, pnNumber, &ch))
{
(*pnNumber)--;
return FALSE;
}
sValue+=ch;
break;
default:
sValue+=ch;
break;
}
break;
case OX_REGEXP_TAG_CHAR_NOT_NEW_LINE:
case OX_REGEXP_TAG_DIGIT:
case OX_REGEXP_TAG_NON_DIGIT:
case OX_REGEXP_TAG_WHITESPACE:
case OX_REGEXP_TAG_NON_WHITESPACE:
case OX_REGEXP_TAG_ANY_WORD:
case OX_REGEXP_TAG_ANY_NON_WORD:
int nRet;
switch (ch)
{
case TEXT('{'):
int nMin, nMax;
nRet=GetMinMaxCount(sString, pnNumber, &nMin, &nMax);
if (!nRet)
{
(*pnNumber)--;
return FALSE;
}
switch (nRet)
{
case OX_REGEXP_TAG_CHARS_EXACTLY:
AddTag(nType, NULL, nMin, nMin);
break;
case OX_REGEXP_TAG_CHARS_AT_LEAST:
AddTag(nType, NULL, nMin, -1);
break;
case OX_REGEXP_TAG_CHARS_AT_LEAST_MOST:
AddTag(nType, NULL, nMin, nMax);
break;
default:
ASSERT(FALSE);
}
break;
case TEXT('?'):
AddTag(nType, NULL, 0, 1);
break;
case TEXT('*'):
AddTag(nType, NULL, 0, -1);
break;
case TEXT('+'):
AddTag(nType, NULL, 1, -1);
break;
case TEXT('|'):
{
(*pnNumber)--;
SetError(OX_REGEXP_ERROR_MUST_CHAR_BEFORE);
return FALSE;
}
default:
AddTag(OX_REGEXP_TAG_CHAR_NOT_NEW_LINE, NULL);
ASSERT(sValue.IsEmpty());
sValue+=ch;
break;
}
nType=OX_REGEXP_TAG_COMMON_CHAR;
break;
case OX_REGEXP_TAG_CHARS_EITHER:
{
TCHAR chEither;
ASSERT(!sValue.IsEmpty());
(*pnNumber)--;
BOOL bContinue=FALSE;
do{
if (!GetEither(sString, pnNumber, &chEither))
{
(*pnNumber)--;
return FALSE;
}
if (sValue.Find(chEither)==-1)
sValue+=chEither;
if (sString.GetLength()>*pnNumber &&
sString.GetAt(*pnNumber)==TEXT('|'))
{
bContinue=TRUE;
(*pnNumber)++;
}
else
bContinue=FALSE;
}while(sString.GetLength()>*pnNumber
&& bContinue);
if (bContinue)
{
(*pnNumber)--;
SetError(OX_REGEXP_ERROR_UNEXPECTED_END_EITHER);
return FALSE;
}
AddTag(OX_REGEXP_TAG_CHARSET, &sValue);
sValue="";
nType=OX_REGEXP_TAG_COMMON_CHAR;
}
break;
case OX_REGEXP_TAG_CHARSET:
if (ch==TEXT('^') && sValue.IsEmpty())
{
nType=OX_REGEXP_TAG_NON_CHARSET;
continue;
}
case OX_REGEXP_TAG_NON_CHARSET:
case OX_REGEXP_TAG_PATTERN:
case OX_REGEXP_TAG_CHARSET_BEGIN_LINE:
case OX_REGEXP_TAG_NON_CHARSET_BEGIN_LINE:
case OX_REGEXP_TAG_CHARSET_END_LINE:
case OX_REGEXP_TAG_NON_CHARSET_END_LINE:
case OX_REGEXP_TAG_CHARSET_BEGIN_END_LINE:
case OX_REGEXP_TAG_NON_CHARSET_BEGIN_END_LINE:
switch (ch)
{
case TEXT('^'):
if (nType==OX_REGEXP_TAG_PATTERN)
{
(*pnNumber)--;
SetError(OX_REGEXP_ERROR_UNEXPECTED_SPECCHAR);
return FALSE;
}
switch (nType)
{
case OX_REGEXP_TAG_NON_CHARSET:
nType=OX_REGEXP_TAG_NON_CHARSET_BEGIN_LINE;
break;
case OX_REGEXP_TAG_CHARSET_END_LINE:
nType=OX_REGEXP_TAG_CHARSET_BEGIN_END_LINE;
break;
case OX_REGEXP_TAG_CHARSET:
nType=OX_REGEXP_TAG_CHARSET_BEGIN_LINE;
break;
case OX_REGEXP_TAG_NON_CHARSET_END_LINE:
nType=OX_REGEXP_TAG_NON_CHARSET_BEGIN_END_LINE;
break;
case OX_REGEXP_TAG_CHARSET_BEGIN_LINE:
case OX_REGEXP_TAG_NON_CHARSET_BEGIN_LINE:
case OX_REGEXP_TAG_CHARSET_BEGIN_END_LINE:
case OX_REGEXP_TAG_NON_CHARSET_BEGIN_END_LINE:
break;
default:
ASSERT(FALSE);
break;
}
break;
case TEXT('$'):
if (nType==OX_REGEXP_TAG_PATTERN)
{
(*pnNumber)--;
SetError(OX_REGEXP_ERROR_UNEXPECTED_SPECCHAR);
return FALSE;
}
switch (nType)
{
case OX_REGEXP_TAG_NON_CHARSET:
nType=OX_REGEXP_TAG_NON_CHARSET_END_LINE;
break;
case OX_REGEXP_TAG_CHARSET_BEGIN_LINE:
nType=OX_REGEXP_TAG_CHARSET_BEGIN_END_LINE;
break;
case OX_REGEXP_TAG_CHARSET:
nType=OX_REGEXP_TAG_CHARSET_END_LINE;
break;
case OX_REGEXP_TAG_NON_CHARSET_BEGIN_LINE:
nType=OX_REGEXP_TAG_NON_CHARSET_BEGIN_END_LINE;
break;
case OX_REGEXP_TAG_CHARSET_END_LINE:
case OX_REGEXP_TAG_NON_CHARSET_END_LINE:
case OX_REGEXP_TAG_CHARSET_BEGIN_END_LINE:
case OX_REGEXP_TAG_NON_CHARSET_BEGIN_END_LINE:
break;
default:
ASSERT(FALSE);
break;
}
break;
case TEXT('*'):
case TEXT('+'):
case TEXT('?'):
case TEXT('.'):
case TEXT('('):
case TEXT('|'):
case TEXT('}'):
case TEXT('['):
{
(*pnNumber)--;
SetError(OX_REGEXP_ERROR_UNEXPECTED_SPECCHAR);
return FALSE;
}
case TEXT(']'):
if (nType!=OX_REGEXP_TAG_PATTERN)
{
AddTag(nType,&sValue);
sValue="";
nType=OX_REGEXP_TAG_COMMON_CHAR;
break;
}
else
{
(*pnNumber)--;
SetError(OX_REGEXP_ERROR_UNEXPECTED_SPECCHAR);
return FALSE;
}
case TEXT('\\'):
{
int nRet=GetSpecialChar(sString, pnNumber,&ch);
if (nRet!=OX_REGEXP_TAG_COMMON_CHAR)
{
if (nRet)
SetError(OX_REGEXP_ERROR_UNEXPECTED_SPECCHAR);
(*pnNumber)--;
return FALSE;
}
if (nType==OX_REGEXP_TAG_PATTERN)
sValue+=ch;
else
if (sValue.Find(ch)==-1)
sValue+=ch;
}
break;
case TEXT('/'):
if (!GetAsciiChar(sString, pnNumber, &ch))
{
(*pnNumber)--;
return FALSE;
}
if (nType==OX_REGEXP_TAG_PATTERN)
sValue+=ch;
else
if (sValue.Find(ch)==-1)
sValue+=ch;
break;
case TEXT('{'):
{
if (sValue.IsEmpty())
{
(*pnNumber)--;
SetError(OX_REGEXP_ERROR_MUST_CHAR_BEFORE);
return FALSE;
}
int nMin,nMax;
int nRet=GetMinMaxCount(sString, pnNumber, &nMin, &nMax);
if (nRet!=OX_REGEXP_TAG_CHARS_EXACTLY)
{
if (nRet)
SetError(OX_REGEXP_ERROR_UNEXPECTED_MATCH);
(*pnNumber)--;
return FALSE;
}
if (nType==OX_REGEXP_TAG_PATTERN)
{
for (int n=1;n<nMin;n++)
sValue+=sValue.Right(1);
}
else
if (sValue.Find(sValue.Right(1))==-1)
sValue+=sValue.Right(1);
}
break;
case TEXT(')'):
if (nType==OX_REGEXP_TAG_PATTERN)
{
AddTag(OX_REGEXP_TAG_PATTERN, &sValue);
sValue="";
nType=OX_REGEXP_TAG_COMMON_CHAR;
break;
}
else
{
SetError(OX_REGEXP_ERROR_UNEXPECTED_SPECCHAR);
(*pnNumber)--;
return FALSE;
}
default:
if (nType==OX_REGEXP_TAG_PATTERN)
sValue+=ch;
else
if (sValue.Find(ch)==-1)
sValue+=ch;
}
break;
default:
ASSERT(FALSE);//unknown type!
break;
}
}
//check for errores
switch (nType)
{
case OX_REGEXP_TAG_COMMON_CHAR:
if (!sValue.IsEmpty())
AddTag(nType, &sValue);
break;
case OX_REGEXP_TAG_CHAR_NOT_NEW_LINE:
case OX_REGEXP_TAG_DIGIT:
case OX_REGEXP_TAG_NON_DIGIT:
case OX_REGEXP_TAG_WHITESPACE:
case OX_REGEXP_TAG_NON_WHITESPACE:
case OX_REGEXP_TAG_ANY_WORD:
case OX_REGEXP_TAG_ANY_NON_WORD:
AddTag(nType, NULL);
break;
case OX_REGEXP_TAG_CHARS_EITHER:
SetError(OX_REGEXP_ERROR_UNEXPECTED_END_EITHER);
return FALSE;
case OX_REGEXP_TAG_PATTERN:
SetError(OX_REGEXP_ERROR_UNEXPECTED_END_OF_STRING);
return FALSE;
case OX_REGEXP_TAG_CHARSET:
case OX_REGEXP_TAG_NON_CHARSET:
case OX_REGEXP_TAG_CHARSET_BEGIN_LINE:
case OX_REGEXP_TAG_NON_CHARSET_BEGIN_LINE:
case OX_REGEXP_TAG_CHARSET_END_LINE:
case OX_REGEXP_TAG_NON_CHARSET_END_LINE:
case OX_REGEXP_TAG_CHARSET_BEGIN_END_LINE:
case OX_REGEXP_TAG_NON_CHARSET_BEGIN_END_LINE:
SetError(OX_REGEXP_ERROR_UNEXPECTED_END_EITHER);
return FALSE;
}
return TRUE;
}
// Get backdrop pattern
short display_get_pattern(BOOL use_custom)
{
APTR iff;
BPTR file;
struct WBPatternPrefs pattern[NUM_PATTERNS];
short a;
char *data[NUM_PATTERNS],*filename;
short change=0;
ULONG flags=0;
// Copy from system fields to custom fields (if custom field is empty, or custom flag is not set)
for (a=0;a<4;a++)
{
if (!GUI->env_BackgroundPic[a][0] || !use_custom)
{
strcpy(GUI->env_BackgroundPic[a],environment->env->env_BackgroundPic[a]);
GUI->env_BackgroundFlags[a]=environment->env->env_BackgroundFlags[a];
GUI->env_BackgroundBorderColour[a]=environment->env->env_BackgroundBorderColour[a];
}
}
// Pattern disabled?
if (environment->env->display_options&DISPOPTF_NO_BACKDROP)
{
// Check both patterns are invalid
for (a=0;a<NUM_PATTERNS;a++)
{
// Is pattern valid?
if (GUI->pattern[a].valid)
{
// Clear existing pattern
display_update_pattern(a,0);
// Free pattern data
FreeVec(GUI->pattern[a].data);
GUI->pattern[a].data=0;
// Free pattern
FreePattern(&GUI->pattern[a]);
}
}
return 0;
}
// Use pattern prefs?
if (environment->env->display_options&DISPOPTF_USE_WBPATTERN)
{
// End pattern notification
stop_file_notify(GUI->pattern_notify);
// Get filename
filename=(IntuitionBase->LibNode.lib_Version<39)?"env:sys/wb.pat":"env:sys/wbpattern.prefs";
// User-specified file?
if (environment->env->backdrop_prefs[0])
{
BPTR lock;
// Does file exist?
if (lock=Lock(environment->env->backdrop_prefs,ACCESS_READ))
{
// Yep
UnLock(lock);
filename=environment->env->backdrop_prefs;
}
}
// Initialise pattern and data pointers
for (a=0;a<NUM_PATTERNS;a++)
{
pattern[a]=GUI->pattern[a].prefs;
data[a]=0;
}
// Try to open wbpattern prefs file
if (IntuitionBase->LibNode.lib_Version>=39 &&
(iff=IFFOpen(filename,IFF_READ,ID_PREF)))
{
ULONG id;
// Scan for chunks we know and love
while (id=IFFNextChunk(iff,0))
{
// FastIPrefs FIP0 chunk?
if (id==ID_FIP0)
{
// Get flags
IFFReadChunkBytes(iff,&flags,sizeof(flags));
}
// PTRN chunk?
else
if (id==ID_PTRN)
{
struct WBPatternPrefs *prefs;
// Allocate space for chunk
if (prefs=AllocVec(IFFChunkSize(iff),MEMF_CLEAR))
{
// Read chunk
IFFReadChunkBytes(iff,prefs,-1);
// Pattern we can handle?
if (prefs->wbp_Which==WBP_ROOT ||
prefs->wbp_Which==WBP_DRAWER)
{
// Copy data
CopyMem(
(char *)prefs,
(char *)&pattern[prefs->wbp_Which],
sizeof(struct WBPatternPrefs));
// Allocate pattern data
if (prefs->wbp_DataLength>0 &&
(data[prefs->wbp_Which]=AllocVec(prefs->wbp_DataLength+1,MEMF_CLEAR)))
{
// Copy pattern data
CopyMem((char *)(prefs+1),data[prefs->wbp_Which],prefs->wbp_DataLength);
}
}
// Free chunk
FreeVec(prefs);
}
}
}
// Close iff file
IFFClose(iff);
}
// Couldn't find it, try for wb.pat
else
if (IntuitionBase->LibNode.lib_Version<39 &&
(file=Open(filename,MODE_OLDFILE)))
{
// Allocate pattern data
if (data[PATTERN_MAIN]=AllocVec(96,MEMF_CLEAR))
{
// Skip forwards
Seek(file,20,OFFSET_CURRENT);
// Read pattern
if ((Read(file,data[PATTERN_MAIN],96))<96)
{
FreeVec(data[PATTERN_MAIN]);
data[PATTERN_MAIN]=0;
}
// Fill out WBPatternPrefs
else
{
pattern[PATTERN_MAIN].wbp_Flags=WBPF_PATTERN;
pattern[PATTERN_MAIN].wbp_Depth=GUI->screen_pointer->BitMap.Depth;
if (pattern[PATTERN_MAIN].wbp_Depth>MAXDEPTH)
pattern[PATTERN_MAIN].wbp_Depth=MAXDEPTH;
}
}
// Close file
Close(file);
}
// Start notification of wbpattern prefs
GUI->pattern_notify=start_file_notify(filename,NOTIFY_PATTERN_CHANGED,GUI->appmsg_port);
}
// Otherwise, under 39 user-defined pictures
else
if (GfxBase->LibNode.lib_Version>=39)
{
short pat;
// Do both patterns
for (pat=0;pat<NUM_PATTERNS;pat++)
{
// Got valid picture?
if (GUI->env_BackgroundPic[pat][0])
{
// Fill out WBPatternPrefs
pattern[pat].wbp_Flags=0;
pattern[pat].wbp_Which=pat;
pattern[pat].wbp_DataLength=strlen(GUI->env_BackgroundPic[pat]);
if (data[pat]=AllocVec(pattern[pat].wbp_DataLength+1,0))
strcpy(data[pat],GUI->env_BackgroundPic[pat]);
}
// Set to no pattern
else
{
// Fill out WBPatternPrefs
pattern[pat].wbp_Flags=WBPF_PATTERN;
pattern[pat].wbp_DataLength=0;
data[pat]=0;
}
}
}
// Otherwise, default to no pattern
else
{
short pat;
// Do both patterns
for (pat=0;pat<NUM_PATTERNS;pat++)
{
// Fill out WBPatternPrefs
pattern[pat].wbp_Flags=WBPF_PATTERN;
pattern[pat].wbp_DataLength=0;
data[pat]=0;
}
}
// Go through both patterns
for (a=0;a<NUM_PATTERNS;a++)
{
BOOL diff=0;
short precision=0;
// Using Opus settings?
if (!(environment->env->display_options&DISPOPTF_USE_WBPATTERN))
{
// Get precision
if (GUI->env_BackgroundFlags[a]&ENVBF_PRECISION_NONE)
precision=-1;
else
if (GUI->env_BackgroundFlags[a]&ENVBF_PRECISION_GUI)
precision=2;
else
if (GUI->env_BackgroundFlags[a]&ENVBF_PRECISION_ICON)
precision=1;
else
if (GUI->env_BackgroundFlags[a]&ENVBF_PRECISION_EXACT)
precision=3;
}
// Maybe set in prefs
else
{
// Get precision
precision=(a==0)?PATF_WB_MODE(flags):PATF_LISTER_MODE(flags);
}
// Valid data?
if (data[a])
{
// No last pattern?
if (!GUI->pattern[a].data)
{
diff=1;
}
// Changed from pattern to picture or vice versa?
else
if ((pattern[a].wbp_Flags&WBPF_PATTERN && !(GUI->pattern[a].prefs.wbp_Flags&WBPF_PATTERN)) ||
(!(pattern[a].wbp_Flags&WBPF_PATTERN) && GUI->pattern[a].prefs.wbp_Flags&WBPF_PATTERN))
{
diff=1;
}
// Pattern pattern?
else
if (pattern[a].wbp_Flags&WBPF_PATTERN)
{
// Different depth?
if (pattern[a].wbp_Depth!=GUI->pattern[a].prefs.wbp_Depth) diff=1;
// Has data changed from the last one?
else
{
short num,d;
// Get amount of data
num=PAT_HEIGHT*pattern[a].wbp_Depth;
// Compare data
for (d=0;d<num;d++)
{
if (((USHORT *)data[a])[d]!=((USHORT *)GUI->pattern[a].data)[d])
{
diff=1;
break;
}
}
}
}
// Picture?
else
{
// Different name for picture, or it's random?
if (strcmp(data[a],GUI->pattern[a].data)!=0 || GUI->pattern[a].random)
{
diff=1;
}
// Precision changed?
else
if (precision!=GUI->pattern[a].precision)
{
diff=1;
}
// Stretching changed?
else
if (a==0 &&
((GUI->env_BackgroundFlags[a]&ENVBF_STRETCH_PIC && !(GUI->pattern[a].flags&PATF_STRETCH)) ||
!(GUI->env_BackgroundFlags[a]&ENVBF_STRETCH_PIC) && (GUI->pattern[a].flags&PATF_STRETCH)))
{
diff=1;
}
// Centering changed?
else
if ((GUI->env_BackgroundFlags[a]&ENVBF_CENTER_PIC && !(GUI->pattern[a].flags&PATF_CENTER)) ||
!(GUI->env_BackgroundFlags[a]&ENVBF_CENTER_PIC) && (GUI->pattern[a].flags&PATF_CENTER))
{
diff=2;
}
}
}
// Had last data?
else
if (GUI->pattern[a].data) diff=1;
if (diff!=1)
{
// Border pen changed?
if ((GUI->env_BackgroundFlags[a]&ENVBF_USE_COLOUR && GUI->pattern[a].border_pen==0) ||
(!(GUI->env_BackgroundFlags[a]&ENVBF_USE_COLOUR) && GUI->pattern[a].border_pen!=0))
{
diff=3;
}
else
if (GUI->pattern[a].border_pen!=0 && GUI->env_BackgroundFlags[a]&ENVBF_USE_COLOUR)
{
ULONG col[3];
GetPalette32(
&GUI->screen_pointer->ViewPort,
col,
1,
(GUI->pattern[a].border_pen==-1)?0:GUI->pattern[a].border_pen);
if (ENVBF_COL_R_GET(col[0])!=ENVBF_COL_R_GET(GUI->env_BackgroundBorderColour[a]) ||
ENVBF_COL_R_GET(col[1])!=ENVBF_COL_G_GET(GUI->env_BackgroundBorderColour[a]) ||
ENVBF_COL_R_GET(col[2])!=ENVBF_COL_B_GET(GUI->env_BackgroundBorderColour[a]))
{
diff=3;
}
}
}
// Has it changed?
if (diff)
{
// Existing pattern valid?
if (GUI->pattern[a].valid)
{
// Clear existing patterns
display_update_pattern(a,0);
}
// Change more than centering?
if (diff==1)
{
// Free existing pattern
FreePattern(&GUI->pattern[a]);
FreeVec(GUI->pattern[a].data);
// Copy pattern and data pointer
GUI->pattern[a].prefs=pattern[a];
GUI->pattern[a].data=data[a];
// Stretch?
if (a==0 && GUI->env_BackgroundFlags[a]&ENVBF_STRETCH_PIC)
{
flags|=PATF_STRETCH;
flags&=~PATF_CENTER;
}
else
{
flags&=~PATF_STRETCH;
if (!(environment->env->display_options&DISPOPTF_USE_WBPATTERN) &&
GUI->env_BackgroundFlags[a]&ENVBF_CENTER_PIC)
flags|=PATF_CENTER;
else
flags&=~PATF_CENTER;
}
// Set flags and precision
GUI->pattern[a].flags=flags;
GUI->pattern[a].precision=precision;
// Initialise pattern
GetPattern(
&GUI->pattern[a],
GUI->screen_pointer,
GUI->env_BackgroundBorderColour[a]|(GUI->env_BackgroundFlags[a]&ENVBF_USE_COLOUR));
}
// Change colour
else
if (diff==3)
{
// Initialise pattern colour
GetPatternBorder(
&GUI->pattern[a],
GUI->screen_pointer,
GUI->env_BackgroundBorderColour[a]|(GUI->env_BackgroundFlags[a]&ENVBF_USE_COLOUR));
}
// Centering changed
else
{
// Environment flags set for centering?
if (!(environment->env->display_options&DISPOPTF_USE_WBPATTERN) &&
GUI->env_BackgroundFlags[a]&ENVBF_CENTER_PIC)
GUI->pattern[a].flags|=PATF_CENTER;
else
GUI->pattern[a].flags&=~PATF_CENTER;
}
// Install new pattern
display_update_pattern(a,1);
}
// If not, free data
else FreeVec(data[a]);
}
return change;
}
OP_STATUS ContentDetector::LookUpInSniffTable(const char *octets, unsigned long octets_length, BOOL must_be_non_scriptable, BOOL check_with_mask,
BOOL specific_type_only, ContentDetectorSimpleType specific_type, int &found_at_index)
{
found_at_index = -1;
unsigned char pattern[PATTERN_MAX_LENGTH];
unsigned char mask[PATTERN_MAX_LENGTH];
for (int index = 0; index < NUMBER_OF_MIMETYPES; index++)
{
if (must_be_non_scriptable && GetPatternData(index).scriptable != SAFE)
continue;
if (specific_type_only && GetPatternData(index).simple_type != specific_type)
continue;
unsigned int octet_index = 0;
unsigned int pattern_index = 0;
GetPattern(index, pattern);
unsigned int pattern_length = GetPatternData(index).length;
if (octets_length < pattern_length)
continue;
// if needed, check for arbitrary amount of white spaces.
if (pattern[0] == WS)
{
while (octet_index < octets_length)
{
char c = octets[octet_index];
if (!op_isspace(c) || c == 0x0B) // vertical tabs (0x0B) not included.
{
break;
}
octet_index++;
}
if (octet_index == octets_length)
continue;
pattern_index++;
}
BOOL check_if_octets_terminate_with_space_or_bracket = FALSE;
char last_octet = 0; // dummy value, not used if check_if_octets_terminate_with_space_or_bracket == FALSE
if (pattern[pattern_length - 1] == SB)
{
last_octet = octets[pattern_length - 1 - pattern_index + octet_index];
pattern_length--;
check_if_octets_terminate_with_space_or_bracket = TRUE;
}
unsigned potential_octet_match_length = MIN(octets_length - octet_index, pattern_length - pattern_index);
if (check_with_mask)
{
GetMask(index, mask);
BOOL match = TRUE;
for (unsigned i = 0; i < potential_octet_match_length && match; ++i)
match = (octets[octet_index+i] & mask[pattern_index+i]) == pattern[pattern_index+i];
if (!match)
continue;
}
else if (op_memcmp(octets + octet_index, pattern + pattern_index, potential_octet_match_length) != 0)
continue;
if (check_if_octets_terminate_with_space_or_bracket && last_octet != 0x20 && last_octet != 0x3E)
continue;
found_at_index = index;
break;
}
return OpStatus::OK;
}
