static void _split_arg(const char_t *pbeg, const char_t *pend, std::vector<_ArgItem> &vArg, bool bAddHead)
{
const char_t *px=pbeg,*pbx=NULL;
int nhead=0; //number of anonymous varibles, which must be placed at the start of command-line
int ni=0; //number of named varibles, which can be placed anywhere after anonymous varibles
int nq=0; //number of quotes
while(px<pend)
{
if(
(*px==_TX('-')&&px+1!=pend&&_istalpha((ushort)px[1])||*px==_TX('/'))&&(px==pbeg||_istspace((ushort)px[-1]))
)
{//the beginning of a named varible, either the following two cases:
// 1) '-' followed by alphabetic letters ('-' followed by number may be an negative number)
// 2) '/' followed by any character
if((nq&1)==0) //if not in double quotes
{
if(pbx)
{//save the value of previous varible
vArg.back().m_value.append(pbx,px);
}
pbx=_skip_non_space(px,pend); //the end of the varible name
vArg.push_back(_ArgItem());
vArg.back().m_name=string_t(px+1,pbx);
px=pbx;
++ni;
}
}
else
if(ni==0&&bAddHead&&!_istspace((ushort)*px))
{//the beginning of an anonymous varible
const char_t *px0=px;
px=_skip_non_str_non_space(px,pend);
char_t buf[16];
_stprintf(buf,_TX("#%d"),nhead); //make an name for the varible
vArg.push_back(_ArgItem());
vArg.back().m_name=buf;
vArg.back().m_value=string_t(px0,px);
++nhead;
}
else
{
if(*px==_TX('\"')&&(px==pbeg||px[-1]!=_CH_CVT))
{
++nq;
}
}
++px;
}
if(pbx&&ni>0)
{//save the value of the last varible
vArg.back().m_value.append(pbx,pend);
}
}
_FF_BEG
//=============================================================================================================
static char_t _cvt_special_char(char_t ch)
{
char_t rch=ch;
switch(ch)
{
case _TX('\"'):
case _CH_CVT:
case _TX('$'):
case _TX('-'):
case _TX('/'):
break;
case _TX('n'):
rch=_TX('\n');
break;
case _TX('t'):
rch=_TX('\t');
break;
default:
// FVT_WARNING("error_unknown_special_char",string_t(&ch,&ch+1));
;
}
return rch;
}
static char_t *_skip_dquotes(const char_t *pbeg, const char_t *pend)
{
assert(pbeg<pend&&*pbeg==_TX('\"'));
while(++pbeg!=pend)
{
if(*pbeg==_TX('\"')&&pbeg[-1]!=_CH_CVT)
break;
}
if(pbeg==pend)
{
// vfxReportError("error_unexpected_end_of_string",string_t(pbeg,pend));
}
return (char_t*)pbeg;
}
static void _read_strings(const char_t *pbeg, const char_t *pend, std::vector<string_t> &vstr)
{
if(pbeg&&pend>pbeg)
{
int nq=0;
const char_t *px=pbeg,*pwb=NULL;
while(px!=pend)
{
if(!_istspace((ushort)*px))
{
if(!pwb)
{
pwb=px; nq=0;
}
if(*px==_TX('\"')&&px!=pbeg&&px[-1]!=_CH_CVT)
++nq;
}
else
{
if(pwb&&(nq&1)==0)
{
_pro_arg(pwb,px,nq,vstr);
pwb=NULL;
}
}
++px;
}
if(pwb)
_pro_arg(pwb,px,nq,vstr);
}
}
T_CHAR * GetBuf()
{
if (!data) return ::t_strdup(_TX(""));
T_CHAR * r=(T_CHAR*)realloc(data,(used+1)*sizeof(T_CHAR));
r[used]=0;
data=0;
return r;
}
static int need_full(T_CHAR* ptr)
{
if (is_roman(ptr)) return 1;
if (sepcmp(ptr,_TX("RPG"))) return 1;
while(!separator(*ptr))
{
if (*ptr<'0' || *ptr>'9') return 0;
ptr++;
}
return 1;
}
void CommandArgSet::SetArg(int argc, char_t *argv[])
{
string_t val;
for(int i=1; i<argc; ++i)
{
val+=argv[i];
val.push_back(_TX(' '));
}
this->SetArg(val);
}
static void _get_str_val(const char_t *pbeg, const char_t *px, string_t &str)
{
const char_t *pwb=pbeg;
for(;pwb!=px;++pwb)
{
if(*pwb==_TX('\"')&&(pwb==pbeg||pwb[-1]!=_CH_CVT))
continue;
else
str.push_back(*pwb);
}
}
static bool x_GetAccountNameBySid(PSID sid, string* account, int* domatch = 0)
{
_ASSERT(account);
// Use predefined buffers for account/domain names to avoid additional
// step to get its sizes. According to MSDN max account/domain size
// do not exceed MAX_ACCOUNT_LEN symbols (char or wchar).
TXChar account_name[MAX_ACCOUNT_LEN + 2];
TXChar domain_name [MAX_ACCOUNT_LEN + 2];
DWORD account_size = sizeof(account_name)/sizeof(account_name[0]) - 1;
DWORD domain_size = sizeof(domain_name)/sizeof(domain_name[0]) - 1;
SID_NAME_USE use;
// Always get both account & domain name, even we don't need last.
// Because if domain name is NULL, this function can throw unhandled
// exception in Unicode builds on some platforms.
if ( !LookupAccountSid(NULL, sid,
account_name, &account_size,
domain_name, &domain_size, &use) ) {
CNcbiError::SetFromWindowsError();
return false;
}
// Save account information
account_name[account_size] = _TX('\0');
account->assign(_T_STDSTRING(account_name));
if (domatch) {
domain_name[domain_size] = _TX('\0');
string domain(_T_STDSTRING(domain_name));
if (*domatch != int(use) || domain.empty()
|| NStr::EqualNocase(domain, "builtin")
|| NStr::FindNoCase(domain, " ") != NPOS
/*|| x_DomainIsLocalComputer(domain_name)*/) {
*domatch = 0;
}
}
return true;
}
void ParseValue(string_t &val)
{
if(!val.empty()&&m_idx.empty())
{
if(!_istspace((ushort)*val.rbegin()))
{//append a blank in order to reserve space for '\0' of the last string.
val.push_back(_TX(' '));
}
_create_arg_index(&val[0],&val[0]+val.size(),m_idx);
if(m_idx.empty()) //if contains no string
val.clear();
}
}
static void _cvt_cmd_string(char_t *pbeg, char_t *pend)
{//convert the command-line input
char_t *prx=pbeg, *pwx=pbeg;
while(prx<pend)
{
if(*prx==_CH_CVT&&prx+1!=pend)
{//a double quotation mark that is not the beginning of a string
++prx;
*pwx=_cvt_special_char(*prx);
}
else
if(*prx==_TX('"'))
{//ignore this double quotation mark
++prx; continue;
}
else
*pwx=*prx;
++pwx;
++prx;
}
*pwx=_TX('\0');
}
BEGIN_NCBI_SCOPE
string CWinSecurity::GetUserName(void)
{
TXChar name[UNLEN + 1];
DWORD name_size = sizeof(name) / sizeof(name[0]) - 1;
if ( !::GetUserName(name, &name_size) ) {
CNcbiError::SetFromWindowsError();
return kEmptyStr;
}
name[name_size] = _TX('\0');
return _T_STDSTRING(name);
}
static int _parse_arg(const char_t *const *pps, const char_t *fmt, bool *pval, int count)
{//for bool
for(int i=0;i<count;++i)
pval[i]=true; //default to be true
if(pps&&pps[0])
{
const char_t *ps=pps[0];
for(int i=0;i<count&&ps[i];++i)
{//'+' for true, and '-' for false
if(ps[i]==_TX('-'))
pval[i]=false;
else
if(ps[i]!=_TX('+'))
{
// vfxReportError("error_unknown_bool_char",ps);
return i;
}
}
}
return count;
}
static char_t* _skip_non_str_until_ex(const char_t *pbeg, const char_t *pend, _OpT &op)
{
bool quate=false;
const char_t *px=pbeg;
while(px<pend&&(quate||!op(*px)))
{
if(*px==_TX('"'))
{//if encounter a string enclosed with double quotation mark
if(px==pbeg||px[-1]!=_CH_CVT)
quate=!quate;
}
++px;
}
if(quate)
{
// vfxReportError("error_unexpected_end_of_string",string_t(pbeg,pend));
}
return (char_t*)px;
}
LRESULT CALLBACK CoreWindow::BaseWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
CoreWindow* pTargetWnd = (CoreWindow*)GetProp(hWnd, _TX("CoreWindow_wgl"));
if (!pTargetWnd)
{
if ((uMsg == WM_CREATE) || (uMsg == WM_NCCREATE))
pTargetWnd = (CoreWindow*)((LPCREATESTRUCT)lParam)->lpCreateParams;
else if ( uMsg == WM_INITDIALOG )
pTargetWnd = (CoreWindow*)lParam;
//if (pTargetWnd)
// pTargetWnd->Attach(hWnd);
}
else
{
LRESULT lResult = pTargetWnd->WndProc(hWnd, uMsg, wParam, lParam);
//if (uMsg == WM_DESTROY)
// pTargetWnd->Detach();
return lResult;
}
return DefWindowProc(hWnd, uMsg, wParam, lParam);
}
void run()
{
if (!spec) {Error();return;}
while(*spec)
{
if (*spec=='%')
{
spec++;
if (*spec=='%') {str.AddChar('%');spec++;continue;}
T_CHAR* s1=spec+1;
while(*s1 && *s1!='%') s1++;
if (!*s1) {Error();break;}
*s1=0;
T_CHAR * tag=f(spec,fp);
*s1='%';
/*if (!tag) tag=tag_unknown; */
if (tag && tag[0])
{
found++;
str.AddString(tag);
}
else
{
str.AddString(_TX("?"));
}
if (tag && ff) ff(tag,fp);
spec=s1+1;
}
else if (*spec=='$')
{
spec++;
if (*spec=='$') {str.AddChar('$');spec++;continue;}
T_CHAR * s1=spec+1;
while(*s1 && *s1!='(') s1++;
if (!*s1) {Error();break;}
T_CHAR * s2=s1+1;
if (!skipshit(&s2,_TX(")"))) {Error();break;}
if (!*s2) {Error();break;};
T_CHAR * p=s1+1;
T_CHAR* temp[64];
UINT temp_f[64];
UINT nt=0;
T_CHAR * p1=s1+1;
while(p<=s2 && nt<64)
{
if (!skipshit(&p,_TX(",)"))) {Error();return;}
if (p>s2 || (*p!=',' && *p!=')')) {Error(_TX("internal error"));return;}
T_CHAR bk=*p;
*p=0;
temp[nt]=_FMT(p1,&temp_f[nt]);
nt++;
*p=bk;;
p1=p+1;
p++;
}
*s1=0;
UINT n;
for (n=0; n<TABSIZE(FUNCS); n++)
if (!t_stricmp(spec, FUNCS[n].name))
break;
*s1='(';
if (n != TABSIZE(FUNCS))
{
if (!FUNCS[n].func(nt, temp, temp_f, str))
{
Error(_TX("[INVALID $"));
str.AddString(FUNCS[n].name);
str.AddString(_TX(" SYNTAX]"));
return;
}
}
else
{
Error(_TX("[UNKNOWN FUNCTION]"));
return;
}
for(n=0;n<nt;n++) free(temp[n]);
spec=s2+1;
}
else if (*spec=='\'')
{
spec++;
if (*spec=='\'') {str.AddChar('\'');spec++;continue;}
T_CHAR * s1=spec+1;
while(*s1 && *s1!='\'') s1++;
if (!*s1) {Error();break;}
*s1=0;
str.AddString(spec);
*s1='\'';
spec=s1+1;
}
else if (*spec=='[')
{
spec++;
T_CHAR * s1=spec;
UINT bc=0;
if (!skipshit(&s1,_TX("]"))) {Error();break;}
T_CHAR bk=*s1;
*s1=0;
FMT fmt(this,spec);
fmt.run();
if (fmt.found)
{
str.AddString(fmt.str);
found+=fmt.found;
}
*s1=bk;
spec=s1+1;
}
else if (*spec == ']') {Error();break;}
else
{
str.AddChar(*spec);
spec++;
}
}
}
int IArgSet::Get(const char_t *var, bool *val, int count, int pos )
{
return _parse_arg(this->Query(var,1,pos),_TX(""),val,count);
}
void Error(T_CHAR *e=0)
{
str.Reset();
str.AddString(e ? e : _TX("[SYNTAX ERROR IN FORMATTING STRING]"));
found++; /* force displaying */
}
void AddInt(int i)
{
T_CHAR foo[16];
sprintf(foo,_TX("%i"),i);
AddString(foo);
}
int IArgSet::Get(const char_t *var, double *val, int count, int pos )
{
return _parse_arg_ex(this,count,_TX("%lf"),var,val,count,pos);
}
p += n;
}
else out.AddChar(*p++);
}
return true;
}
struct
{
TEXTFUNC func;
const T_CHAR * name;
}
FUNCS[] =
{
If,_TX("if"),
If2,_TX("if2"),
Upper,_TX("upper"),
Lower,_TX("lower"),
Pad,_TX("pad"),
Cut,_TX("cut"),
PadCut,_TX("padcut"),
Abbr,_TX("abbr"),
Caps,_TX("caps"),
Caps2,_TX("caps2"),
Longest,_TX("longest"),
Shortest,_TX("shortest"),
Iflonger,_TX("iflonger"),
Ifgreater,_TX("ifgreater"),
Num,_TX("num"),Num,_TX("dec"),
Hex,_TX("hex"),
int IArgSet::Get(const char_t *var, string_t *val, int count, int pos )
{
return _parse_arg_ex(this,count,_TX(""),var,val,count,pos);
}
bool CoreWindow::initGL(HWND hWnd)
{
static PIXELFORMATDESCRIPTOR pfd =
{
sizeof(PIXELFORMATDESCRIPTOR),
1,
PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
PFD_TYPE_RGBA,
24,
0, 0, 0, 0, 0, 0,
0,
0,
0,
0, 0, 0, 0,
24, //Z-Buffer
8, //Stencil Buffer
0,
PFD_MAIN_PLANE,
0, //Reserved
0, 0, 0
};
int PixelFormat;
if (!(m_hDC = ::GetDC(hWnd)))
{
KillGLWindow();
MessageBox(NULL,_TX("Can't Create A GL Device Context."),_TX("ERROR"),MB_OK|MB_ICONEXCLAMATION);
return FALSE;
}
if (!(PixelFormat = ChoosePixelFormat(m_hDC, &pfd)))
{
KillGLWindow();
MessageBox(NULL,_TX("Can't Find A Suitable PixelFormat."),_TX("ERROR"),MB_OK|MB_ICONEXCLAMATION);
return FALSE;
}
if (!SetPixelFormat(m_hDC, PixelFormat, &pfd))
{
KillGLWindow();
MessageBox(NULL,_TX("Can't Set The PixelFormat."),_TX("ERROR"),MB_OK|MB_ICONEXCLAMATION);
return FALSE;
}
if (!(m_hRC = wglCreateContext(m_hDC)))
{
KillGLWindow();
MessageBox(NULL,_TX("Can't Create A GL Rendering Context."),_TX("ERROR"),MB_OK|MB_ICONEXCLAMATION);
return FALSE;
}
if (!wglMakeCurrent(m_hDC, m_hRC))
{
KillGLWindow();
MessageBox(NULL,_TX("Can't Activate The GL Rendering Context."),_TX("ERROR"),MB_OK|MB_ICONEXCLAMATION);
return FALSE;
}
ShowWindow(hWnd,SW_SHOW);
return TRUE;
}
bool CoreWindow::createWindow(int x, int y, int width, int height, const TCHAR* title, bool fullscreenmode)
{
WNDCLASS wc;
HWND hWnd;
DWORD dwExStyle;
DWORD dwStyle;
RECT WindowRect;
WindowRect.left = 0;
WindowRect.right = width;
WindowRect.top = 0;
WindowRect.bottom = height;
dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
if (fullscreenmode)
dwStyle = WS_POPUPWINDOW | WS_MAXIMIZE;
else
dwStyle = WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
AdjustWindowRect(&WindowRect, dwStyle, FALSE);
if (!GetClassInfo(GetModuleHandle(NULL), _TX("CoreWindow_wgl"), &wc))
{
// memset(&wcx, 0, sizeof(WNDCLASSEX));
// wcx.cbSize = sizeof(WNDCLASSEX);
wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
wc.lpfnWndProc = (WNDPROC) CoreWindow::BaseWndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = GetModuleHandle(NULL);
wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
wc.lpszMenuName = 0;
wc.lpszClassName = _TX("CoreWindow_wgl");
if (!RegisterClass(&wc))
{
MessageBox(NULL,_TX("Failed To Register The Window Class."),_TX("ERROR"),MB_OK|MB_ICONEXCLAMATION);
ExitProcess(0);
return FALSE;
}
}
hWnd = CreateWindowEx(dwExStyle,
_TX("CoreWindow_wgl"),
title,
dwStyle,
x, y,
WindowRect.right - WindowRect.left,
WindowRect.bottom - WindowRect.top,
NULL,
NULL,
GetModuleHandle(NULL),
(void*)this);//BaseWndProcにthisを渡してやる
if (!hWnd)
{
KillGLWindow();
MessageBox(NULL,_TX("Window Creation Error."),_TX("ERROR"),MB_OK|MB_ICONEXCLAMATION);
ExitProcess(0);
return FALSE;
}
// ウィンドウハンドルとCWindowBaseオブジェクトを結びつける
SetProp(hWnd, _TX("CoreWindow_wgl"), (HANDLE)this);
m_hWnd = hWnd;
if (!g_mainWin)
g_mainWin = this;
return TRUE;
}
