FILE *
SessionImpl::OpenBZip2File (/*[in]*/ const PathName & path)
{
AutoBZ2 autoBz2 (BZ2_bzopen(path.Get(), "rb"));
if (autoBz2.Get() == 0)
{
FATAL_MIKTEX_ERROR ("OpenBZip2File",
T_("BZ2_bzopen() failed for some."),
path.Get());
}
FILE * pFiles[2];
Pipe (pFiles, PIPE_SIZE);
try
{
auto_ptr<BZip2ReaderThreadArg> pArg (new BZip2ReaderThreadArg);
pArg->bzin = autoBz2.Get();
pArg->fileout = pFiles[1];
auto_ptr<Thread> pThread (Thread::Start(BZip2ReaderThread, pArg.get()));
pArg.release ();
autoBz2.Detach ();
return (pFiles[0]);
}
catch (const exception &)
{
if (pFiles[0] != 0)
{
fclose (pFiles[0]);
}
if (pFiles[1] != 0)
{
fclose (pFiles[1]);
}
throw;
}
}
MIKTEXCALLBACK
GZipReaderThread (/*[in]*/ void * pv)
{
try
{
auto_ptr<GZipReaderThreadArg>
pArg (reinterpret_cast<GZipReaderThreadArg*>(pv));
MIKTEX_ASSERT (pArg->gzin != 0);
MIKTEX_ASSERT (pArg->fileout != 0);
AutoGZ autoCloseGZip2Stream (pArg->gzin);
FileStream autoCloseOutput (pArg->fileout);
char buf[PIPE_SIZE];
int len = 0;
while (! ferror(pArg->fileout)
&& (len = gzread(pArg->gzin, buf, ARRAY_SIZE(buf))) > 0)
{
fwrite (buf, 1, len, pArg->fileout);
}
if (len < 0)
{
FATAL_MIKTEX_ERROR ("GZipReaderThread",
T_("gzread() failed for some reason."),
0);
}
if (ferror(pArg->fileout))
{
FATAL_CRT_ERROR ("fwrite", 0);
}
}
catch (const exception &)
{
}
}
MIKTEXCALLBACK
BZip2ReaderThread (/*[in]*/ void * pv)
{
try
{
auto_ptr<BZip2ReaderThreadArg>
pArg (reinterpret_cast<BZip2ReaderThreadArg*>(pv));
MIKTEX_ASSERT (pArg->bzin != 0);
MIKTEX_ASSERT (pArg->fileout != 0);
AutoBZ2 autoCloseBZip2Stream (pArg->bzin);
FileStream autoCloseOutput (pArg->fileout);
char buf[PIPE_SIZE];
int len;
while (! ferror(pArg->fileout)
&& (len = BZ2_bzread(pArg->bzin, buf, ARRAY_SIZE(buf))) > 0)
{
fwrite (buf, 1, len, pArg->fileout);
}
int bzerr;
BZ2_bzerror (pArg->bzin, &bzerr);
if (bzerr != BZ_OK)
{
FATAL_MIKTEX_ERROR ("BZip2ReaderThread",
T_("BZ2_bzread() failed for some reason."),
0);
}
if (ferror(pArg->fileout))
{
FATAL_CRT_ERROR ("fwrite", 0);
}
}
catch (const exception &)
{
}
}
size_t Iterator::Count(Environment &env, const Value &criteria)
{
Signal &sig = env.GetSignal();
if (IsInfinite()) {
SetError_InfiniteNotAllowed(sig);
return 0;
}
size_t cnt = 0;
if (criteria.Is_function()) {
const Function *pFunc = criteria.GetFunction();
Value value;
while (Next(env, value)) {
AutoPtr<Argument> pArg(new Argument(pFunc));
if (!pArg->StoreValue(env, value)) return 0;
Value valueFlag = pFunc->Eval(env, *pArg);
if (sig.IsSignalled()) return 0;
if (valueFlag.GetBoolean()) cnt++;
}
if (sig.IsSignalled()) return 0;
} else {
Value value;
while (Next(env, value)) {
int cmp = Value::Compare(env, value, criteria);
if (sig.IsSignalled()) return 0;
if (cmp == 0) cnt++;
}
}
return cnt;
}
Tcl_Obj *Object_interp::ConvToTclObj(Environment &env, Signal &sig, const Value &value)
{
if (value.IsInvalid()) {
return ::Tcl_NewStringObj("", 0);
} else if (value.Is_boolean()) {
return ::Tcl_NewBooleanObj(value.GetBoolean());
} else if (value.Is_binary()) {
const Binary &binary = value.GetBinary();
return ::Tcl_NewByteArrayObj(
reinterpret_cast<const unsigned char *>(binary.data()), static_cast<int>(binary.size()));
} else if (value.Is_number()) {
Number num = value.GetNumber();
if (static_cast<Number>(static_cast<long>(num)) == num) {
return ::Tcl_NewLongObj(static_cast<long>(num));
} else {
return ::Tcl_NewDoubleObj(num);
}
} else if (value.Is_list()) {
int objc;
Tcl_Obj **objv = CreateTclObjArray(env, sig, value.GetList(), &objc);
if (!sig.IsSignalled()) {
return ::Tcl_NewListObj(objc, objv);
}
} else if (value.Is_string()) {
const char *str = value.GetString();
return ::Tcl_NewStringObj(str, static_cast<int>(::strlen(str)));
} else if (value.Is_function()) {
Handler *pHandler = new Handler(Object_interp::Reference(this),
Object_function::Reference(Object_function::GetObject(value)));
String cmdName = NewCommandName();
::Tcl_CreateCommand(_interp, cmdName.c_str(), CommandProc,
pHandler, CommandDeleteProc);
return ::Tcl_NewStringObj(cmdName.c_str(), static_cast<int>(cmdName.size()));
} else if (value.IsType(VTYPE_variable)) {
const Object_variable *pObjVariable =
dynamic_cast<const Object_variable *>(value.GetObject());
const char *varName = pObjVariable->GetVarName();
return ::Tcl_NewStringObj(varName, static_cast<int>(::strlen(varName)));
} else if (value.IsObject()) {
Object *pObj = value.GetObject();
const Function *pFunc =
pObj->LookupFunction(Gura_UserSymbol(__tclname__), ENVREF_Escalate);
if (pFunc != nullptr) {
Value valueThis(pObj, VFLAG_NoFundOwner); // reference to self
AutoPtr<Argument> pArg(new Argument(pFunc));
pArg->SetValueThis(valueThis);
Value result = pFunc->Eval(*pObj, *pArg);
if (!sig.IsSignalled()) {
return ConvToTclObj(env, sig, result);
}
}
}
String str = value.ToString(false);
return ::Tcl_NewStringObj(str.c_str(), static_cast<int>(str.size()));
}
PlugInArg* getPlugInArgByIndex(PlugInArgList* pPial, uint32_t argNum)
{
if (pPial == NULL)
{
setLastError(SIMPLE_BAD_PARAMS);
return NULL;
}
PlugInArg* pArg(NULL);
if (!pPial->getArg(argNum, pArg))
{
setLastError(SIMPLE_NOT_FOUND);
return NULL;
}
setLastError(SIMPLE_NO_ERROR);
return pArg;
}
PlugInArg* getPlugInArgByName(PlugInArgList* pPial, const char* pArgName)
{
if (pPial == NULL || pArgName == NULL)
{
setLastError(SIMPLE_BAD_PARAMS);
return NULL;
}
std::string argName(pArgName == NULL ? "" : pArgName);
PlugInArg* pArg(NULL);
if (!pPial->getArg(argName, pArg))
{
setLastError(SIMPLE_NOT_FOUND);
return NULL;
}
setLastError(SIMPLE_NO_ERROR);
return pArg;
}
//++ ------------------------------------------------------------------------------------
// Details: Given a set of command argument objects retrieve the argument with the
// specified name.
// Type: Method.
// Args: vpArg - (W) A pointer to a command's argument object.
// Return: True - Argument found.
// False - Argument not found.
// Throws: None.
//--
bool CMICmdArgSet::GetArg( const CMIUtilString & vArgName, CMICmdArgValBase *& vpArg ) const
{
bool bFound = false;
SetCmdArgs_t::const_iterator it = m_setCmdArgs.begin();
while( it != m_setCmdArgs.end() )
{
CMICmdArgValBase * pArg( *it );
if( pArg->GetName() == vArgName )
{
bFound = true;
vpArg = pArg;
break;
}
// Next
++it;
}
return bFound;
}
size_t Iterator::Find(Environment &env, const Value &criteria, Value &value)
{
Signal &sig = env.GetSignal();
if (criteria.Is_function()) {
if (IsInfinite()) {
SetError_InfiniteNotAllowed(sig);
return InvalidSize;
}
const Function *pFunc = criteria.GetFunction();
while (Next(env, value)) {
AutoPtr<Argument> pArg(new Argument(pFunc));
if (!pArg->StoreValue(env, value)) return InvalidSize;
Value valueFlag = pFunc->Eval(env, *pArg);
if (sig.IsSignalled()) return InvalidSize;
if (valueFlag.GetBoolean()) return GetIndexCur();
}
if (sig.IsSignalled()) return InvalidSize;
} else if (criteria.Is_list() || criteria.Is_iterator()) {
AutoPtr<Iterator> pIteratorCriteria(criteria.CreateIterator(sig));
if (sig.IsSignalled()) return InvalidSize;
if (IsInfinite() && pIteratorCriteria->IsInfinite()) {
SetError_InfiniteNotAllowed(sig);
return InvalidSize;
}
while (Next(env, value)) {
Value valueCriteria;
if (!pIteratorCriteria->Next(env, valueCriteria)) break;
if (valueCriteria.GetBoolean()) return GetIndexCur();
}
return InvalidSize;
} else {
while (Next(env, value)) {
//int cmp = Value::Compare(env, value, criteria);
//if (sig.IsSignalled()) return InvalidSize;
//if (cmp == 0) return GetIndexCur();
if (value.Is(criteria)) return GetIndexCur();
}
}
return InvalidSize;
}
//++ ------------------------------------------------------------------------------------
// Details: Release resources used by *this container object.
// Type: Method.
// Args: None.
// Return: None.
// Throws: None.
//--
void CMICmdArgSet::Destroy( void )
{
// Delete command argument objects
if( !m_setCmdArgs.empty() )
{
SetCmdArgs_t::iterator it = m_setCmdArgs.begin();
while( it != m_setCmdArgs.end() )
{
CMICmdArgValBase * pArg( *it );
delete pArg;
// Next
++it;
}
m_setCmdArgs.clear();
}
m_setCmdArgsThatNotValid.clear();
m_setCmdArgsThatAreMissing.clear();
m_setCmdArgsNotHandledByCmd.clear();
m_setCmdArgsMissingInfo.clear();
m_bIsArgsPresentButNotHandledByCmd = false;
}
//-----------------------------------------------------------------------------
// SuffixMgrEntryCustom
//-----------------------------------------------------------------------------
Value SuffixMgrEntryCustom::DoEval(Environment &env, const char *body) const
{
AutoPtr<Argument> pArg(new Argument(_pFunc.get()));
if (!pArg->StoreValue(env, Value(body))) return Value::Nil;
return _pFunc->Eval(env, *pArg);
}
