map < unsigned int, ustring > resource_get_books(const ustring & templatefile)
{
map < unsigned int, ustring > books;
GKeyFile *keyfile = g_key_file_new();
if (g_key_file_load_from_file(keyfile, templatefile.c_str(), G_KEY_FILE_NONE, NULL)) {
vector < unsigned int >ids = books_type_to_ids(btUnknown);
for (unsigned int i = 0; i < ids.size(); i++) {
ustring english_name = books_id_to_english(ids[i]);
gchar *value;
value = g_key_file_get_string(keyfile, resource_template_books_group(), english_name.c_str(), NULL);
if (value) {
books[i] = value;
g_free(value);
}
}
g_key_file_free(keyfile);
}
return books;
}
ReadText::ReadText(const ustring & file, bool silent, bool trimming)
{
// Reads the text and stores it line by line, trimmed, into "lines".
// If "silent" is true, then no exception will be thrown in case of an error.
// The lines will be trimmed if "trimming" is true.
ifstream in(file.c_str());
if (!in) {
if (!silent) {
cerr << _("Error opening file ") << file << endl;
throw;
}
return;
}
string s;
while (getline(in, s)) {
if (trimming)
s = trim(s);
lines.push_back(s);
}
}
inline void operator() (ustring name, Dual2<R> &result, const Dual2<S> &s,
const S &sp,
ShaderGlobals *sg, const NoiseParams *opt) const {
if (name == Strings::uperlin || name == Strings::noise) {
PeriodicNoise noise;
noise(result, s, sp);
} else if (name == Strings::perlin || name == Strings::snoise) {
PeriodicSNoise snoise;
snoise(result, s, sp);
} else if (name == Strings::cell) {
PeriodicCellNoise cellnoise;
cellnoise(result.val(), s.val(), sp);
result.clear_d();
} else if (name == Strings::gabor) {
GaborPNoise gnoise;
gnoise (name, result, s, sp, sg, opt);
} else {
((ShadingContext *)sg->context)->error ("Unknown noise type \"%s\"", name.c_str());
}
}
void EditorActionChangeParagraphStyle::set_style (const ustring& style)
{
// Define the work area.
GtkTextIter startiter;
gtk_text_buffer_get_start_iter (paragraph->textbuffer, &startiter);
GtkTextIter enditer;
gtk_text_buffer_get_end_iter (paragraph->textbuffer, &enditer);
// Apply the style in such a way that the paragraph style is always applied first,
// then after that the character styles.
vector <ustring> current_character_styles = get_character_styles_between_iterators (startiter, enditer);
gtk_text_buffer_remove_all_tags (paragraph->textbuffer, &startiter, &enditer);
gtk_text_buffer_apply_tag_by_name (paragraph->textbuffer, style.c_str(), &startiter, &enditer);
for (unsigned int i = 0; i < current_character_styles.size(); i++) {
if (!current_character_styles[i].empty()) {
gtk_text_buffer_get_iter_at_offset (paragraph->textbuffer, &startiter, i);
enditer = startiter;
gtk_text_iter_forward_char (&enditer);
gtk_text_buffer_apply_tag_by_name (paragraph->textbuffer, current_character_styles[i].c_str(), &startiter, &enditer);
}
}
}
YesNoAlwaysDialog::YesNoAlwaysDialog(const ustring& message, bool default_yes)
{
gtkbuilder = gtk_builder_new ();
gtk_builder_add_from_file (gtkbuilder, gw_build_filename (Directories->get_package_data(), "gtkbuilder.yesnoalwaysdialog.xml").c_str(), NULL);
dialog = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "dialog"));
label = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "label"));
gtk_label_set_text (GTK_LABEL (label), message.c_str());
checkbutton = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "checkbutton"));
// Add the buttons. In the standard question dialog, the Yes is at the right, then the No following to the left.
gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_NO, GTK_RESPONSE_NO);
gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_YES, GTK_RESPONSE_YES);
if (default_yes)
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_YES);
else
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_NO);
}
bool WinGroups::cache_by_user(const ustring& name, const ustring& dom)
{
// Cache groups that contains USER "name".
const DWORD dwLevel = 0, dwPrefMaxLen = MAX_PREFERRED_LENGTH, dwFlags = LG_INCLUDE_INDIRECT;
DWORD dwEntriesRead = 0, dwTotalEntries = 0;
NET_API_STATUS nStatus;
clear();
m_dom = dom;
LPGROUP_USERS_INFO_0 info = nullptr;
nStatus = ::NetUserGetLocalGroups(m_dom.c_str(), name.c_str(), dwLevel, dwFlags, (PBYTE*)&info, dwPrefMaxLen, &dwEntriesRead, &dwTotalEntries);
if (nStatus == NERR_Success || nStatus == ERROR_MORE_DATA) {
for (DWORD i = 0; i < dwEntriesRead; ++i) {
GroupInfo gtmp;
gtmp.name = info[i].grui0_name;
gtmp.comm = Group::get_comm(info[i].grui0_name);
push_back(gtmp);
}
::NetApiBufferFree(info);
}
return (NERR_Success == nStatus);
}
bool windowsoutpost_telnet(const ustring & hostname)
// This makes a connection with the Outpost on "host" and then disconnects again.
// It returns true if this worked out.
{
bool success = false;
struct sockaddr_in address;
struct hostent *host;
int sock;
host = gethostbyname(hostname.c_str());
if (host) {
#ifdef WIN32
if ((sock = socket(PF_INET, SOCK_STREAM, 0)) != SOCKET_ERROR)
#else
if ((sock = socket(PF_INET, SOCK_STREAM, 0)) >= 0)
#endif
{
address.sin_family = AF_INET;
memcpy(&address.sin_addr, host->h_addr_list[0], sizeof(address.sin_addr));
#ifdef WIN32
WSAHtons(sock, 51515, &address.sin_port);
if (connect(sock, (struct sockaddr *)&address, sizeof(address)) == SOCKET_ERROR)
#else
address.sin_port = htons(51515);
if (connect(sock, (struct sockaddr *)&address, sizeof(address)))
#endif
{
; // success = false;
} else {
success = true;
}
#ifdef WIN32
closesocket(sock);
#else
close(sock);
#endif
}
}
return success;
}
void AudioOpenAL::scan_music_dir (const ustring& path,
vector<MusicFile>& files, MusicType type) {
double len;
ustring file_path;
MusicFile entry;
logger.fineln ("searching %s for music files", path.c_str ());
try {
Dir dir (path);
for (DirIterator it = dir.begin (); it != dir.end (); it++) {
if ((*it)[0] == '.')
continue;
file_path = path + (*it);
MplayerDecoder dec;
len = dec.get_length (file_path);
if (len <= 0)
continue;
if (type == MT_GameShort && len > 150) {
continue;
}
if (type == MT_GameLong && len <= 150) {
continue;
}
logger.fineln ("found music file %s", file_path.c_str ());
entry.filename = file_path;
entry.played = false;
files.push_back (entry);
}
} catch (FileError) {
}
}
std::string
OSLCompilerImpl::retrieve_source (ustring filename, int line)
{
// If we don't already have the file open, open it
if (filename != m_last_sourcefile) {
// If we have another file open, close that one
if (m_sourcefile)
fclose (m_sourcefile);
m_last_sourcefile = filename;
m_sourcefile = fopen (filename.c_str(), "r");
if (! m_sourcefile) {
m_last_sourcefile = ustring();
return "<not found>";
}
}
// If we want something *before* the last line read in the open file,
// rewind to the beginning.
if (m_last_sourceline > line) {
rewind (m_sourcefile);
m_last_sourceline = 0;
}
// Now read lines up to and including the file we want.
char buf[10240];
while (m_last_sourceline < line) {
if (fgets (buf, sizeof(buf), m_sourcefile))
++m_last_sourceline;
else
break;
}
// strip trailing newline
if (buf[strlen(buf)-1] == '\n')
buf[strlen(buf)-1] = '\0';
return std::string (buf);
}
bool WinUsers::cache_by_group(const ustring& group, const ustring& dom) {
// Cache members of group "name".
const DWORD dwLevel = 1, dwPrefMaxLen = MAX_PREFERRED_LENGTH;
DWORD dwEntriesRead = 0, dwTotalEntries = 0;
ULONG_PTR dwResumeHandle = 0;
NET_API_STATUS nStatus;
clear();
m_group = group;
m_dom = dom;
do {
PLOCALGROUP_MEMBERS_INFO_1 info = nullptr;
nStatus = ::NetLocalGroupGetMembers(m_dom.c_str(), group.c_str(), dwLevel, (PBYTE*) &info,
dwPrefMaxLen, &dwEntriesRead, &dwTotalEntries, &dwResumeHandle);
if (NERR_Success == nStatus || ERROR_MORE_DATA == nStatus) {
PLOCALGROUP_MEMBERS_INFO_1 ptr = info;
for (DWORD i = 0; i < dwEntriesRead && ptr; ++i, ++ptr) {
push_back(UserInfo(UserBuf(ptr->lgrmi1_name).data()));
}
::NetApiBufferFree(info);
}
} while (ERROR_MORE_DATA == nStatus);
return (NERR_Success == nStatus);
}
ustring CheckMatchingPairs::get_context(ustring & line, unsigned int offset)
// Returns the context at offset: A couple of words before and after.
{
// Result.
ustring returnvalue;
// Load text into buffer.
GtkTextBuffer *textbuffer;
textbuffer = gtk_text_buffer_new(NULL);
gtk_text_buffer_set_text(textbuffer, line.c_str(), -1);
// Iterators.
GtkTextIter iter1;
GtkTextIter iter2;
// Find boundaries of context to return.
gtk_text_buffer_get_iter_at_offset(textbuffer, &iter1, offset);
iter2 = iter1;
gtk_text_iter_backward_word_starts(&iter1, 2);
gtk_text_iter_forward_word_ends(&iter2, 2);
return gtk_text_iter_get_text(&iter1, &iter2);
// Free memory
g_object_unref(textbuffer);
// Give us the result.
return returnvalue;
}
bool ColorSpaceManager::colorspace_is_data(ustring colorspace)
{
if (colorspace == u_colorspace_auto || colorspace == u_colorspace_raw ||
colorspace == u_colorspace_srgb) {
return false;
}
#ifdef WITH_OCIO
OCIO::ConstConfigRcPtr config = OCIO::GetCurrentConfig();
if (!config) {
return false;
}
try {
OCIO::ConstColorSpaceRcPtr space = config->getColorSpace(colorspace.c_str());
return space && space->isData();
}
catch (OCIO::Exception &) {
return false;
}
#else
return false;
#endif
}
bool mechon_mamre_copyright(const ustring & inputfile)
// Returns true is a file has "Copyright" and "Mechon Mamre" in it.
{
// Read the file.
gchar *contents;
gsize length;
GError *error = NULL;
if (!g_file_get_contents(inputfile.c_str(), &contents, &length, &error)) {
gw_critical(error->message);
g_error_free(error);
return false;
}
// Search for the signature.
char *mechonmamre = g_strstr_len(contents, 400, _("Mechon Mamre"));
if (mechonmamre) {
mechonmamre = g_strstr_len(contents, 400, _("Copyright"));
}
// Free memory and return result.
g_free(contents);
if (mechonmamre)
return true;
else
return false;
}
int
RendererServices::pointcloud_search (ShaderGlobals *sg,
ustring filename, const OSL::Vec3 ¢er,
float radius, int max_points, bool sort,
size_t *out_indices,
float *out_distances, int derivs_offset)
{
#if USE_PARTIO
if (! filename)
return 0;
PointCloud *pc = PointCloud::get(filename);
if (pc == NULL) { // The file failed to load
sg->context->shadingsys().error ("pointcloud_search: could not open \"%s\"", filename.c_str());
return 0;
}
spin_lock lock (pc->m_mutex);
Partio::ParticlesDataMutable *cloud = pc->m_partio_cloud;
if (cloud == NULL) { // The file failed to load
sg->context->shadingsys().error ("pointcloud_search: could not open \"%s\"", filename.c_str());
return 0;
}
// Early exit if the pointcloud contains no particles.
if (cloud->numParticles() == 0)
return 0;
// If we need derivs of the distances, we'll need access to the
// found point's positions.
Partio::ParticleAttribute *pos_attr = NULL;
if (derivs_offset) {
pos_attr = pc->m_attributes[u_position].get();
if (! pos_attr)
return 0; // No "position" attribute -- fail
}
ASSERT (sizeof(size_t) == sizeof(Partio::ParticleIndex) &&
"Only will work if Partio ParticleIndex is the size of a size_t");
// FIXME -- if anybody cares about an architecture in which that is not
// the case, we can easily allocate local space to retrieve the indices,
// then copy them back to the caller's indices.
Partio::ParticleIndex *indices = (Partio::ParticleIndex *)out_indices;
float *dist2 = out_distances;
if (! dist2) // If not supplied, allocate our own
dist2 = (float *)sg->context->alloc_scratch (max_points*sizeof(float), sizeof(float));
float finalRadius;
int count = cloud->findNPoints (¢er[0], max_points, radius,
indices, dist2, &finalRadius);
// If sorting, allocate some temp space and sort the distances and
// indices at the same time.
if (sort && count > 1) {
SortedPointRecord *sorted = (SortedPointRecord *) sg->context->alloc_scratch (count * sizeof(SortedPointRecord), sizeof(SortedPointRecord));
for (int i = 0; i < count; ++i)
sorted[i] = SortedPointRecord (dist2[i], indices[i]);
std::sort (sorted, sorted+count, SortedPointCompare());
for (int i = 0; i < count; ++i) {
dist2[i] = sorted[i].first;
indices[i] = sorted[i].second;
}
}
if (out_distances) {
// Convert the squared distances to straight distances
for (int i = 0; i < count; ++i)
out_distances[i] = sqrtf(dist2[i]);
if (derivs_offset) {
// We are going to need the positions if we need to compute
// distance derivs
OSL::Vec3 *positions = (OSL::Vec3 *) sg->context->alloc_scratch (sizeof(OSL::Vec3) * count, sizeof(float));
cloud->data (*pos_attr, count, indices, true, (void *)positions);
const OSL::Vec3 &dCdx = (¢er)[1];
const OSL::Vec3 &dCdy = (¢er)[2];
float *d_distance_dx = out_distances + derivs_offset;
float *d_distance_dy = out_distances + derivs_offset * 2;
for (int i = 0; i < count; ++i) {
d_distance_dx[i] = 1.0f / out_distances[i] *
((center.x - positions[i].x) * dCdx.x +
(center.y - positions[i].y) * dCdx.y +
(center.z - positions[i].z) * dCdx.z);
d_distance_dy[i] = 1.0f / out_distances[i] *
((center.x - positions[i].x) * dCdy.x +
(center.y - positions[i].y) * dCdy.y +
(center.z - positions[i].z) * dCdy.z);
}
}
}
return count;
#else
return 0;
#endif
}
HANDLE Facade::Open(const ustring& path, ACCESS_MASK access, DWORD share, PSECURITY_ATTRIBUTES sa, DWORD creat, DWORD flags)
{
// LogTrace(L"'%s', 0x%08X, 0x%08X, %p\n", path.c_str(), access, share, sa);
return CheckHandleErr(::CreateFileW(path.c_str(), access, share, sa, creat, flags, nullptr));
}
bool search_in_bibledit_word_boundaries_match(const ustring & text, const ustring & searchword, bool matchbeginning, bool matchending, bool globbing)
// Does the word boundary matching.
{
/*
Deal with matching the start of a word and/or of the end.
There are four cases here.
1. Match word start only.
2. Match word end only.
3. Both match start end end of a word, which implies "whole word".
4. No matching at all.
Boundary resolution is handled by pango_break(). Textual boundaries such
as word boundaries and line boundaries are determined for each item.
In most cases a general algorithm suffices for this process, but in some
cases a language module will override the generic algorithm with a more
specific one.
It seems to be easier programming to use GtkTextIter and GtkTextBuffer,
rather than pango_break() directly.
*/
// Whether the word matches.
bool match = false;
// Textbuffer for determining word boundaries.
GtkTextBuffer *textbuffer = gtk_text_buffer_new(NULL);
gtk_text_buffer_set_text(textbuffer, text.c_str(), -1);
// Iterators needed.
GtkTextIter startiter;
GtkTextIter enditer;
// Store segments of text to compare against.
vector < ustring > segments;
// Deal with case one: Match word start only.
if (matchbeginning && !matchending) {
// Create a patternword for the glob-style pattern matching.
ustring patternword = searchword + "*";
// Collect all strings starting with a word.
gtk_text_buffer_get_start_iter(textbuffer, &startiter);
gtk_text_buffer_get_end_iter(textbuffer, &enditer);
while (gtk_text_iter_forward_word_end(&startiter)) {
gtk_text_iter_backward_word_start(&startiter);
segments.push_back(gtk_text_iter_get_text(&startiter, &enditer));
gtk_text_iter_forward_word_end(&startiter);
}
// See whether the word is in it.
for (unsigned int i2 = 0; i2 < segments.size(); i2++) {
if (globbing) {
// Glob-style pattern matching.
if (g_pattern_match_simple(patternword.c_str(), segments[i2].c_str())) {
match = true;
break;
}
} else {
// Straight compare.
if (segments[i2].find(searchword) == 0) {
match = true;
break;
}
}
}
}
// Deal with case two: Match word end only.
if (!matchbeginning && matchending) {
// Create a patternword for the glob-style pattern matching.
ustring patternword = "*" + searchword;
// Collect all strings ending with a word.
gtk_text_buffer_get_start_iter(textbuffer, &startiter);
gtk_text_buffer_get_start_iter(textbuffer, &enditer);
while (gtk_text_iter_forward_word_end(&enditer)) {
segments.push_back(gtk_text_iter_get_text(&startiter, &enditer));
}
// See whether the word is in it.
for (unsigned int i2 = 0; i2 < segments.size(); i2++) {
if (globbing) {
// Glob-style pattern matching.
if (g_pattern_match_simple(patternword.c_str(), segments[i2].c_str())) {
match = true;
break;
}
} else {
// Straight compare.
size_t matchposition;
matchposition = segments[i2].length() - searchword.length();
// Negative match positions cause a false match. Solve that here.
matchposition = CLAMP(matchposition, 0, 99999999);
if (segments[i2].find(searchword) == matchposition) {
match = true;
break;
}
}
}
}
// Deal with case three: Match both word start and end.
// Interpreted as "match whole word".
if (matchbeginning && matchending) {
// Create a patternword for the glob-style pattern matching.
ustring patternword = searchword;
// Collect all whole words.
gtk_text_buffer_get_start_iter(textbuffer, &enditer);
while (gtk_text_iter_forward_word_end(&enditer)) {
startiter = enditer;
gtk_text_iter_backward_word_start(&startiter);
segments.push_back(gtk_text_iter_get_text(&startiter, &enditer));
}
// See whether the word is in it.
for (unsigned int i2 = 0; i2 < segments.size(); i2++) {
if (globbing) {
// Glob-style pattern matching.
if (g_pattern_match_simple(patternword.c_str(), segments[i2].c_str())) {
match = true;
break;
}
} else {
// Straight compare.
if (segments[i2] == searchword) {
match = true;
break;
}
}
}
}
// Case four: Nothing to test, so set found to true.
if (!matchbeginning && !matchending)
match = true;
// Free memory.
g_object_unref(textbuffer);
// Return whether match.
return match;
}
void LuaInstance::pushStack( const ustring& value ) {
pushStack( value.c_str() );
}
Node node(const ustring& name)
{
LogTrace2(L"('%s')", name.c_str());
return simstd::make_shared<ImplNodeEx>(name);
}
bool operator < ( const DebugResult &rhs ) const
{
return name.c_str() < rhs.name.c_str();
}
void User::set_script(const ustring& name, const ustring& in, const ustring& dom) {
const DWORD level = 1009;
USER_INFO_1009 info;
info.usri1009_script_path = const_cast<PWSTR>(in.c_str());
set_info(name, dom, level, &info);
}
void WinUsers::add(const ustring& name, const ustring& pass) {
User::add(name, pass);
push_back(UserInfo(UserBuf(name).data()));
if (!m_group.empty())
Group::add_member(m_group, Sid(name.c_str()));
}
void set(const ustring& name, const ustring& dom = ustring()) {
CheckApiError(::NetUserSetInfo(dom.c_str(), name.c_str(), 3, (PBYTE)info, nullptr));
}
int
RendererServices::pointcloud_get (ShaderGlobals *sg,
ustring filename, size_t *indices, int count,
ustring attr_name, TypeDesc attr_type,
void *out_data)
{
#if USE_PARTIO
if (! count)
return 1; // always succeed if not asking for any data
PointCloud *pc = PointCloud::get(filename);
if (pc == NULL) { // The file failed to load
sg->context->shadingsys().error ("pointcloud_get: could not open \"%s\"", filename.c_str());
return 0;
}
spin_lock lock (pc->m_mutex);
Partio::ParticlesDataMutable *cloud = pc->m_partio_cloud;
if (cloud == NULL) { // The file failed to load
sg->context->shadingsys().error ("pointcloud_get: could not open \"%s\"", filename.c_str());
return 0;
}
// lookup the ParticleAttribute pointer needed for a query
Partio::ParticleAttribute *attr = pc->m_attributes[attr_name].get();
if (! attr) {
sg->context->shadingsys().error ("Accessing unexisting attribute %s in pointcloud \"%s\"", attr_name.c_str(), filename.c_str());
return 0;
}
// Now make sure that types are compatible
TypeDesc element_type = attr_type.elementtype ();
int attr_partio_type = 0;
// Convert the OSL (OIIO) type to the equivalent Partio type
if (element_type == TypeDesc::TypeFloat)
attr_partio_type = Partio::FLOAT;
else if (element_type == TypeDesc::TypeInt)
attr_partio_type = Partio::INT;
else if (element_type == TypeDesc::TypeColor || element_type == TypeDesc::TypePoint ||
element_type == TypeDesc::TypeVector || element_type == TypeDesc::TypeNormal)
attr_partio_type = Partio::VECTOR;
else {
// error ("Unsupported attribute type %s for pointcloud query in attribute %s",
// element_type.c_str(), attr_name.c_str());
return 0;
}
// Finally check for some equivalent types like float3 and vector
if (!compatiblePartioType(attr, attr_partio_type)) {
sg->context->shadingsys().error ("Type of attribute \"%s\" : %s[%d] not compatible with OSL's %s in \"%s\" pointcloud",
attr_name.c_str(), partioTypeString(attr), attr->count,
element_type.c_str(), filename.c_str());
return 0;
}
ASSERT (sizeof(size_t) == sizeof(Partio::ParticleIndex) &&
"Only will work if Partio ParticleIndex is the size of a size_t");
// FIXME -- if anybody cares about an architecture in which that is not
// the case, we can easily allocate local space to retrieve the indices,
// then copy them back to the caller's indices.
// Actual data query
cloud->data (*attr, count, (Partio::ParticleIndex *)indices,
true, out_data);
return 1;
#else
return 0;
#endif
}
bool operator < ( const ustring &rhs ) const
{
return name.c_str() < rhs.c_str();
}
const wchar_t* ImplNodeEx::name() const noexcept
{
return name_.c_str();
}
void WebkitBrowser::go_to(const ustring & url)
{
webkit_web_view_open (WEBKIT_WEB_VIEW(webview), url.c_str());
}
Node node(const ustring& name, const Node& parent)
{
LogTrace2(L"('%s', '%s')", name.c_str(), parent ? parent->name() : L"");
return simstd::make_shared<ImplNodeEx>(name, parent);
}
UserBuf(const ustring& name, const ustring& dom = ustring()) {
CheckApiError(::NetUserGetInfo(dom.c_str(), name.c_str(), 3, (PBYTE*)&info));
}
ustring script_filter(const ustring & scriptname, bool straightthrough, const ustring & inputfile, const ustring & outputfile)
/*
Runs the filter "scriptname".
Input text in "inputfile", and the output text goes in "outputfile".
If everything is okay, it returns nothing.
If there were errors, it returns these.
*/
{
// Remove any previous output.
unlink(outputfile.c_str());
unlink(script_temporal_error_file().c_str());
// Handle straight through.
if (straightthrough) {
unix_cp(inputfile, outputfile);
return "";
}
// Get the filename and the type of the script.
ScriptType scripttype;
ustring scriptfile = script_get_path(scriptname, &scripttype, true);
// If the rules file does not exist, or the script is of an unknown type, pass it straight through.
if (!g_file_test(scriptfile.c_str(), G_FILE_TEST_IS_REGULAR) || (scripttype == stEnd)) {
unix_cp(inputfile, outputfile);
gw_warning(_("Error in script ") + scriptname);
return "";
}
// Encode the input usfm file.
ustring encodedinputfile = script_temporal_input_file();
if (inputfile != encodedinputfile) {
unix_cp(inputfile, encodedinputfile);
}
script_encode_usfm_file(encodedinputfile);
// Run filter.
ustring command;
ustring error;
switch (scripttype) {
case stSed:
{
command.append(script_sed_binary());
command.append(" -f");
command.append(shell_quote_space(scriptfile));
command.append("<");
command.append(shell_quote_space(encodedinputfile));
command.append(">");
command.append(shell_quote_space(outputfile));
break;
}
case stTECkit:
{
command.append(script_teckit_txtconverter());
command.append(" -i");
command.append(shell_quote_space(encodedinputfile));
command.append(" -o");
command.append(shell_quote_space(outputfile));
command.append(" -t");
command.append(shell_quote_space(scriptfile));
command.append(" -nobom");
break;
}
case stFree:
{
// Text of the script.
ustring scriptdata;
{
// Read script.
gchar *contents;
g_file_get_contents(scriptfile.c_str(), &contents, NULL, NULL);
if (contents) {
scriptdata = contents;
g_free(contents);
} else {
error = _("Can't read script file");
gw_warning(error);
return error;
}
}
// Check for and insert the input filename.
if (scriptdata.find(script_free_input_identifier()) == string::npos) {
error = _("Can't find where to put input file");
gw_warning(error);
return error;
}
replace_text(scriptdata, script_free_input_identifier(), shell_quote_space(encodedinputfile));
// Check for and insert the output filename.
if (scriptdata.find(script_free_output_identifier()) == string::npos) {
error = _("Can't find where to put output file");
gw_warning(error);
return error;
}
replace_text(scriptdata, script_free_output_identifier(), shell_quote_space(outputfile));
// Write temporal script.
g_file_set_contents(script_temporal_script_file().c_str(), scriptdata.c_str(), -1, NULL);
// Assemble command to run.
command.append("sh");
command.append(shell_quote_space(script_temporal_script_file()));
break;
}
case stEnd:
{
break;
}
}
// Add the error file to the command, and run it.
command.append(" 2> ");
command.append(script_temporal_error_file());
int result = system(command.c_str()); // This one is too unpredictable to be used with GwSpawn.
// The filters are so much beyond any control that we never can be sure that
// their output is in the UTF-8 encoding.
// Sed would give UTF-8, but as TECkit can also give legacy encodings.
// We can't know what free scripts will do, it could be anything.
// So here check the UTF-8 encoding.
// If UTF-8 validation fails, we copy the input straight to the output.
{
gchar *contents;
g_file_get_contents(outputfile.c_str(), &contents, NULL, NULL);
if (contents) {
if (!g_utf8_validate(contents, -1, NULL)) {
unix_cp(inputfile, outputfile);
error = _("UTF-8 validation failure");
gw_warning(error);
}
g_free(contents);
if (!error.empty())
return error;
}
}
// Decode the output file.
script_decode_usfm_file(outputfile);
// Handle OK.
if (result == 0)
return "";
// Handle error.
gchar *contents;
g_file_get_contents(script_temporal_error_file().c_str(), &contents, NULL, NULL);
if (contents) {
error = contents;
g_free(contents);
gw_warning(error);
}
return error;
}
bool operator < ( const UserData &rhs ) const
{
return name.c_str() < rhs.name.c_str();
}
