transfer.cc

Bug Summary

File:	transfer.cc
Warning:	line 767, column 93 Potential leak of memory pointed to by 'myword'
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name transfer.cc -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/tmp/build/apertium/apertium-3.9.12+g928~04ac90c6/apertium -resource-dir /usr/lib/llvm-16/lib/clang/16 -D HAVE_CONFIG_H -I . -I .. -I /usr/include/utf8cpp/ -I /usr/local/include -I /usr/include/libxml2 -I /usr/local/include -D PIC -internal-isystem /usr/lib/llvm-16/bin/../include/c++/v1 -internal-isystem /usr/lib/llvm-16/lib/clang/16/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -std=c++2b -fdeprecated-macro -fdebug-compilation-dir=/tmp/build/apertium/apertium-3.9.12+g928~04ac90c6/apertium -ferror-limit 19 -fgnuc-version=4.2.1 -fno-implicit-modules -fcxx-exceptions -fexceptions -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/build/apertium/scan-build/2024-09-11-155328-205384-1 -x c++ transfer.cc
1/*
* Copyright (C) 2005--2015 Universitat d'Alacant / Universidad de Alicante
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <https://www.gnu.org/licenses/>.
*/
17#include <apertium/transfer.h>

19#include <lttoolbox/string_utils.h>
20#include <lttoolbox/xml_walk_util.h>

22#include <iostream>

24using namespace std;

26Transfer::Transfer()
27{}

29void
30Transfer::readBil(string const &fstfile)
31{
FILE *in = fopen(fstfile.c_str(), "rb");
if(!in)
{
  cerr << "Error: Could not open file '" << fstfile << "'." << endl;
  exit(EXIT_FAILURE1);
}
fstp.load(in);
fstp.initBiltrans();
fclose(in);
41}

43void
44Transfer::setExtendedDictionary(string const &fstfile)
45{
FILE *in = fopen(fstfile.c_str(), "rb");
if(!in)
{
  cerr << "Error: Could not open extended dictionary file '" << fstfile << "'." << endl;
  exit(EXIT_FAILURE1);
}
extended.load(in);
extended.initBiltrans();
fclose(in);
isExtended = true;
56}

58void
59Transfer::read(string const &transferfile, string const &datafile,
      string const &fstfile)
61{
TransferBase::read(transferfile.c_str(), datafile.c_str());
if (getattr(root_element, "default") == "chunk"_u) {
  defaultAttrs = chunk;
} else {
  defaultAttrs = lu;
}
if (!fstfile.empty()) {
  readBil(fstfile);
}
71}

73bool
74Transfer::checkIndex(xmlNode *element, int index, int limit)
75{
if(index >= limit)
{
  cerr << "Error in " << (char *) doc->URL << ": line " << element->line << ": index >= limit" << endl;
  return false;
}
if(index < 0) {
  cerr << "Error in " << (char *) doc->URL << ": line " << element->line << ": index < 0" << endl;
  return false;
}
if(word[index] == 0)
{
  cerr << "Error in " << (char *) doc->URL << ": line " << element->line << ": Null access at word[index]" << endl;
  return false;
}
return true;
91}

93UString
94Transfer::evalCachedString(xmlNode *element)
95{
TransferInstr& ti = evalStringCache[element];
switch (ti.getType()) {
case ti_clip_sl:
  if (checkIndex(element, ti.getPos(), lword)) {
    if (gettingLemmaFromWord(ti.getContent()) && last_lword > 1) {
      if(in_lu) {
        out_wblank = combineWblanks(out_wblank, word[ti.getPos()]->getWblank());
      } else if (in_let_var) {
        var_out_wblank[var_val] = combineWblanks(var_out_wblank[var_val], word[ti.getPos()]->getWblank());
      }
    }

    return word[ti.getPos()]->source(attr_items[ti.getContent()], ti.getCondition());
  }
  break;

case ti_clip_tl:
  if(checkIndex(element, ti.getPos(), lword)) {
    if(gettingLemmaFromWord(ti.getContent()) && last_lword > 1) {
      if(in_lu) {
        out_wblank = combineWblanks(out_wblank, word[ti.getPos()]->getWblank());
      } else if(in_let_var) {
        var_out_wblank[var_val] = combineWblanks(var_out_wblank[var_val], word[ti.getPos()]->getWblank());
      }
    }

    return word[ti.getPos()]->target(attr_items[ti.getContent()], ti.getCondition());
  }
  break;

case ti_clip_ref:
  if(checkIndex(element, ti.getPos(), lword)) {
    return word[ti.getPos()]->reference(attr_items[ti.getContent()], ti.getCondition());
  }
  break;

case ti_linkto_sl:
  if(checkIndex(element, ti.getPos(), lword)) {
    if(!word[ti.getPos()]->source(attr_items[ti.getContent()], ti.getCondition()).empty()) {
      UString ret;
      ret += '<';
      ret += ti.getStrval();
      ret += '>';
      return ret;
    } else {
      return ""_u;
    }
  }
  break;

case ti_linkto_tl:
  if(checkIndex(element, ti.getPos(), lword)) {
    if(!word[ti.getPos()]->target(attr_items[ti.getContent()], ti.getCondition()).empty()) {
      UString ret;
      ret += '<';
      ret += ti.getStrval();
      ret += '>';
      return ret;
    } else {
      return ""_u;
    }
  }
  break;

case ti_linkto_ref:
  if(checkIndex(element, ti.getPos(), lword)) {
    if(!word[ti.getPos()]->reference(attr_items[ti.getContent()], ti.getCondition()).empty()) {
      UString ret;
      ret += '<';
      ret += ti.getStrval();
      ret += '>';
      return ret;
    } else {
      return ""_u;
    }
  }
  break;

case ti_var:
  if(last_lword > 1) {
    out_wblank = combineWblanks(out_wblank, var_out_wblank[ti.getContent()]);
  }
  return variables[ti.getContent()];

case ti_lit_tag:
case ti_lit:
  return ti.getContent();

case ti_b:
  if(!blank_queue.empty()) {
    UString retblank = blank_queue.front();
    if(in_out) {
      blank_queue.pop();
    }

    return retblank;
  } else {
    return " "_u;
  }
  break;

case ti_get_case_from:
  if(checkIndex(element, ti.getPos(), lword)) {
    return copycase(word[ti.getPos()]->source(attr_items[ti.getContent()]),
                    evalString(ti.getPointer()));
  }
  break;

case ti_case_of_sl:
  if(checkIndex(element, ti.getPos(), lword)) {
    return StringUtils::getcase(word[ti.getPos()]->source(attr_items[ti.getContent()]));
  }
  break;

case ti_case_of_tl:
  if(checkIndex(element, ti.getPos(), lword)) {
    return StringUtils::getcase(word[ti.getPos()]->target(attr_items[ti.getContent()]));
  }
  break;

case ti_case_of_ref:
  if(checkIndex(element, ti.getPos(), lword)) {
    return StringUtils::getcase(word[ti.getPos()]->reference(attr_items[ti.getContent()]));
  }
  break;

default:
  return ""_u;
}
return ""_u;
226}

228void
229Transfer::processClip(xmlNode* element)
230{
int pos = 0;
xmlChar *side = NULL__null;
UString as;
UString part;
bool queue = true;

for(xmlAttr *i = element->properties; i != NULL__null; i = i->next) {
  if(!xmlStrcmp(i->name, (const xmlChar *) "side")) {
    side = i->children->content;
  } else if(!xmlStrcmp(i->name, (const xmlChar *) "part")) {
    part = to_ustring((const char*) i->children->content);
  } else if(!xmlStrcmp(i->name, (const xmlChar *) "pos")) {
    pos = atoi((const char *)i->children->content) - 1;
  } else if(!xmlStrcmp(i->name, (const xmlChar *) "queue")) {
    if(!xmlStrcmp(i->children->content, (const xmlChar *) "no")) {
      queue = false;
    }
  } else if(!xmlStrcmp(i->name, (const xmlChar *) "link-to")) {
    as = to_ustring((const char*)i->children->content);
  }
}

if(!as.empty()) {
  if(!xmlStrcmp(side, (const xmlChar *) "sl")) {
    evalStringCache[element] = TransferInstr(ti_linkto_sl, part, pos, NULL__null, queue, as);
  } else if(!xmlStrcmp(side, (const xmlChar *) "ref")) {
    evalStringCache[element] = TransferInstr(ti_linkto_ref, part, pos, NULL__null, queue, as);
  } else {
    evalStringCache[element] = TransferInstr(ti_linkto_tl, part, pos, NULL__null, queue, as);
  }
} else if(!xmlStrcmp(side, (const xmlChar *) "sl")) {
  evalStringCache[element] = TransferInstr(ti_clip_sl, part, pos, NULL__null, queue);
} else if(!xmlStrcmp(side, (const xmlChar *) "ref")) {
  evalStringCache[element] = TransferInstr(ti_clip_ref, part, pos, NULL__null, queue);
} else {
  evalStringCache[element] = TransferInstr(ti_clip_tl, part, pos, NULL__null, queue);
}
268}

270void
271Transfer::processBlank(xmlNode* element)
272{
evalStringCache[element] = TransferInstr(ti_b, " "_u, -1);
274}

276void
277Transfer::processCaseOf(xmlNode* element)
278{
int pos = 0;
xmlChar *side = NULL__null;
UString part;

for(xmlAttr *i = element->properties; i != NULL__null; i = i->next) {
  if(!xmlStrcmp(i->name, (const xmlChar *) "side")) {
    side = i->children->content;
  } else if(!xmlStrcmp(i->name, (const xmlChar *) "part")) {
    part = to_ustring((const char*) i->children->content);
  } else if(!xmlStrcmp(i->name, (const xmlChar *) "pos")) {
    pos = atoi((const char *) i->children->content) - 1;
  }
}

if(!xmlStrcmp(side, (const xmlChar *) "sl")) {
  evalStringCache[element] = TransferInstr(ti_case_of_sl, part, pos);
} else if(!xmlStrcmp(side, (const xmlChar *) "ref")) {
  evalStringCache[element] = TransferInstr(ti_case_of_ref, part, pos);
} else {
  evalStringCache[element] = TransferInstr(ti_case_of_tl, part, pos);
}
300}

302UString
303Transfer::processLu(xmlNode* element)
304{
in_lu = true;
out_wblank.clear();

UString myword;
for (auto i : children(element)) {
  myword.append(evalString(i));
}

in_lu = false;

// if word == nullptr then we're outputting a word
// inside an npar=0 macro and there's not much we can do
if(last_lword == 1 && word != nullptr) {
  out_wblank = word[0]->getWblank();
}

if(!myword.empty()) {
  if(myword[0] != '[' || myword[1] != '[') {
    UString ret = out_wblank;
    ret += '^';
    ret += myword;
    ret += '$';
    return ret;
  } else {
    myword += '$';
    return myword;
  }
} else {
  return ""_u;
}
335}

337UString
338Transfer::processMlu(xmlNode* element)
339{
UString value;

bool first_time = true;
out_wblank.clear();

in_lu = true;
for (auto i : children(element)) {
  UString myword;
  for (auto j : children(i)) {
    myword.append(evalString(j));
  }

if (!first_time) {
 if(!myword.empty() && myword[0] != '#') { //'+#' problem
      value += '+';
    }
} else {
    if (!myword.empty()) {
   first_time = false;
    }
}

value.append(myword);
}

if(last_lword == 1) {
  out_wblank = word[0]->getWblank();
}

if(!value.empty()) {
  UString ret = out_wblank;
  ret += '^';
  ret += value;
  ret += '$';
  return ret;
} else {
  return ""_u;
}
378}

380void
381Transfer::processLuCount(xmlNode* element)
382{
cerr << "Error: unexpected expression: '" << element->name << "'" << endl;
exit(EXIT_FAILURE1);
385}

387void
388Transfer::processOut(xmlNode *localroot)
389{
in_out = true;

for (auto i : children(localroot)) {
  if(defaultAttrs == lu) {
    if(!xmlStrcmp(i->name, (const xmlChar *) "lu")) {
      write(processLu(i), output);
    } else if(!xmlStrcmp(i->name, (const xmlChar *) "mlu")) {
      write(processMlu(i), output);
    } else { // 'b'
      write(evalString(i), output);
    }
  } else {
    if(!xmlStrcmp(i->name, (const xmlChar *) "chunk")) {
      write(processChunk(i), output);
    } else { // 'b'
      write(evalString(i), output);
    }
  }
}
in_out = false;
410}

412UString
413Transfer::processChunk(xmlNode *localroot)
414{
UString name, namefrom;
UString caseofchunk = "aa"_u;
UString result;

for(xmlAttr *i = localroot->properties; i != NULL__null; i = i->next)
{
  if(!xmlStrcmp(i->name, (const xmlChar *) "name"))
  {
    name = to_ustring((const char *) i->children->content);
  }
  else if(!xmlStrcmp(i->name, (const xmlChar *) "namefrom"))
  {
    namefrom = to_ustring((const char *) i->children->content);
  }
  else if(!xmlStrcmp(i->name, (const xmlChar *) "case"))
  {
    caseofchunk = to_ustring((const char *) i->children->content);
  }
}

result += '^';
if(!caseofchunk.empty() && !dictionary_case)
{
  if(!name.empty())
  {
    result.append(StringUtils::copycase(variables[caseofchunk], name));
  }
  else if(!namefrom.empty())
  {
    result.append(StringUtils::copycase(variables[caseofchunk], variables[namefrom]));
  }
  else
  {
    cerr << "Error: you must specify either 'name' or 'namefrom' for the 'chunk' element" << endl;
    exit(EXIT_FAILURE1);
  }
}
else
{
  if(!name.empty())
  {
    result.append(name);
  }
  else if(!namefrom.empty())
  {
    result.append(variables[namefrom]);
  }
  else
  {
    cerr << "Error: you must specify either 'name' or 'namefrom' for the 'chunk' element" << endl;
    exit(EXIT_FAILURE1);
  }
}

for (auto i : children(localroot)) {
  if(!xmlStrcmp(i->name, (const xmlChar *) "tags")) {
    result.append(processTags(i));
    result += '{';
  } else if(!xmlStrcmp(i->name, (const xmlChar *) "lu")) {
    result.append(processLu(i));
  } else if(!xmlStrcmp(i->name, (const xmlChar *) "mlu")) {
    result.append(processMlu(i));
  } else { // 'b'
    result.append(evalString(i));
  }
}
result += '}';
result += '$';
return result;
484}

486UString
487Transfer::processTags(xmlNode *localroot)
488{
UString result;
for (auto i : children(localroot)) {
  if (!xmlStrcmp(i->name, (const xmlChar*) "tag")) {
    for (auto j : children(i)) {
      result.append(evalString(j));
    }
  }
}
return result;
498}

500void
501Transfer::processLet(xmlNode *localroot)
502{
xmlNode *leftSide = NULL__null, *rightSide = NULL__null;

for (auto i : children(localroot)) {
  if(leftSide == NULL__null) {
    leftSide = i;
  } else {
    rightSide = i;
    break;
  }
}

map<xmlNode *, TransferInstr>::iterator it = evalStringCache.find(leftSide);
if(it != evalStringCache.end())
{
  TransferInstr &ti = it->second;
  switch(ti.getType())
  {
    case ti_var:
      in_let_var = true;
      var_val = ti.getContent();

      var_out_wblank[var_val].clear();

      variables[ti.getContent()] = evalString(rightSide);

      in_let_var = false;

      return;

    case ti_clip_sl:
      if (checkIndex(leftSide, ti.getPos(), lword)) {
        bool match = word[ti.getPos()]->setSource(attr_items[ti.getContent()], evalString(rightSide), ti.getCondition());
        if (!match && trace)
        {
          cerr << "apertium-transfer warning: <let> on line " << localroot->line << " sometimes discards its value." << endl;
        }
      }
      return;

    case ti_clip_tl:
      if (checkIndex(leftSide, ti.getPos(), lword)) {
        bool match = word[ti.getPos()]->setTarget(attr_items[ti.getContent()], evalString(rightSide), ti.getCondition());
        if (!match && trace)
        {
          cerr << "apertium-transfer warning: <let> on line " << localroot->line << " sometimes discards its value." << endl;
        }
      }
      return;

    case ti_clip_ref:
      if (checkIndex(leftSide, ti.getPos(), lword)) {
        bool match = word[ti.getPos()]->setReference(attr_items[ti.getContent()], evalString(rightSide), ti.getCondition());
        if (!match && trace)
        {
          cerr << "apertium-transfer warning: <let> on line " << localroot->line << " sometimes discards its value." << endl;
        }
      }
      return;

    default:
      return;
  }
}
if(leftSide->name != NULL__null && !xmlStrcmp(leftSide->name, (const xmlChar *) "var"))
{
  in_let_var = true;

  UString const val = to_ustring((const char *) leftSide->properties->children->content);

  var_val = val;
  var_out_wblank[var_val].clear();

  variables[val] = evalString(rightSide);

  in_let_var = false;
  evalStringCache[leftSide] = TransferInstr(ti_var, val, 0);
}
else if(!xmlStrcmp(leftSide->name, (const xmlChar *) "clip"))
{
  int pos = 0;
  xmlChar *side = NULL__null, *as = NULL__null;
  UString part;
  bool queue = true;

  for(xmlAttr *i = leftSide->properties; i != NULL__null; i = i->next)
  {
    if(!xmlStrcmp(i->name, (const xmlChar *) "side"))
    {
side = i->children->content;
    }
    else if(!xmlStrcmp(i->name, (const xmlChar *) "part"))
    {
      part = to_ustring((const char*) i->children->content);
    }
    else if(!xmlStrcmp(i->name, (const xmlChar *) "pos"))
    {
pos = atoi((const char *) i->children->content) - 1;
    }
    else if(!xmlStrcmp(i->name, (const xmlChar *) "queue"))
    {
      if(!xmlStrcmp(i->children->content, (const xmlChar *) "no"))
      {
        queue = false;
      }
    }
    else if(!xmlStrcmp(i->name, (const xmlChar *) "link-to"))
    {
      as = i->children->content; // TODO: set but never read
    }
  }

  if (pos >= lword) {
    cerr << "Error: Transfer::processLet() bad access on pos >= lword" << endl;
    return;
  }
  if (word[pos] == 0) {
    cerr << "Error: Transfer::processLet() null access on word[pos]" << endl;
    return;
  }

  if(!xmlStrcmp(side, (const xmlChar *) "tl"))
  {
    bool match = word[pos]->setTarget(attr_items[part], evalString(rightSide), queue);
    if(!match && trace)
    {
      cerr << "apertium-transfer warning: <let> on line " << localroot->line << " sometimes discards its value." << endl;
    }
    evalStringCache[leftSide] = TransferInstr(ti_clip_tl, part, pos, NULL__null, queue);
  }
  else if(!xmlStrcmp(side, (const xmlChar *) "ref"))
  {
    bool match = word[pos]->setReference(attr_items[part], evalString(rightSide), queue);
    if(!match && trace)
    {
      cerr << "apertium-transfer warning: <let> on line " << localroot->line << " sometimes discards its value." << endl;
    }
    evalStringCache[leftSide] = TransferInstr(ti_clip_ref, part, pos, NULL__null, queue);
  }
  else
  {
    bool match = word[pos]->setSource(attr_items[part], evalString(rightSide), queue);
    if(!match && trace)
    {
      cerr << "apertium-transfer warning: <let> on line " << localroot->line << " sometimes discards its value." << endl;
    }
    evalStringCache[leftSide] = TransferInstr(ti_clip_sl, part, pos, NULL__null, queue);
  }
}
651}

653void
654Transfer::processModifyCase(xmlNode *localroot)
655{
if (dictionary_case) return;
xmlNode *leftSide = NULL__null, *rightSide = NULL__null;

for (auto i : children(localroot)) {
  if(leftSide == NULL__null) {
    leftSide = i;
  } else {
    rightSide = i;
    break;
  }
}

if(leftSide->name != NULL__null && !xmlStrcmp(leftSide->name, (const xmlChar *) "clip"))
{
  int pos = 0;
  xmlChar *side = NULL__null, *as = NULL__null;
  UString part;
  bool queue = true;

  for(xmlAttr *i = leftSide->properties; i != NULL__null; i = i->next)
  {
    if(!xmlStrcmp(i->name, (const xmlChar *) "side"))
    {
side = i->children->content;
    }
    else if(!xmlStrcmp(i->name, (const xmlChar *) "part"))
    {
      part = to_ustring((const char*)i->children->content);
    }
    else if(!xmlStrcmp(i->name, (const xmlChar *) "pos"))
    {
pos = atoi((const char *) i->children->content) - 1;
    }
    else if(!xmlStrcmp(i->name, (const xmlChar *) "queue"))
    {
      if(!xmlStrcmp(i->children->content, (xmlChar const *) "no"))
      {
        queue = false;
      }
    }
    else if(!xmlStrcmp(i->name, (const xmlChar *) "link-to"))
    {
      as = i->children->content;
      (void)as; // ToDo, remove "as" and the whole else?
    }
  }
  if(!xmlStrcmp(side, (const xmlChar *) "sl"))
  {
    UString const result = StringUtils::copycase(evalString(rightSide),
		      word[pos]->source(attr_items[part], queue));
    bool match = word[pos]->setSource(attr_items[part], result);
    if(!match && trace)
    {
      cerr << "apertium-transfer warning: <modify-case> on line " << localroot->line << " sometimes discards its value." << endl;
    }
  }
  else if(!xmlStrcmp(side, (const xmlChar *) "ref"))
  {
    UString const result = StringUtils::copycase(evalString(rightSide),
            word[pos]->reference(attr_items[part], queue));
    bool match = word[pos]->setReference(attr_items[part], result);
    if(!match && trace)
    {
      cerr << "apertium-transfer warning: <modify-case> on line " << localroot->line << " sometimes discards its value." << endl;
    }
  }
  else
  {
    UString const result = StringUtils::copycase(evalString(rightSide),
		     word[pos]->target(attr_items[part], queue));
    bool match = word[pos]->setTarget(attr_items[part], result);
    if(!match && trace)
    {
      cerr << "apertium-transfer warning: <modify-case> on line " << localroot->line << " sometimes discards its value." << endl;
    }
  }
}
else if(!xmlStrcmp(leftSide->name, (const xmlChar *) "var"))
{
  UString const val = to_ustring((const char *) leftSide->properties->children->content);
  variables[val] = StringUtils::copycase(evalString(rightSide), variables[val]);
}
738}

740void
741Transfer::processCallMacro(xmlNode *localroot)
742{
UString const n = to_ustring((const char *) localroot->properties->children->content);
int npar = 0;

xmlNode *macro = macro_map[macros[n]];

for(xmlAttr *i = macro->properties; i != NULL__null; i = i->next)
1
Assuming 'i' is not equal to NULL→
2
←
Loop condition is true.  Entering loop body→
{
  if(!xmlStrcmp(i->name, (const xmlChar *) "npar"))
3
←
Assuming the condition is true→
4
←
Taking true branch→
  {
    npar = atoi((const char *) i->children->content);
    break;
  }
}

// ToDo: Is it at all valid if npar <= 0 ?

TransferWord **myword = NULL__null;
5
←
 Execution continues on line 759→
int idx = 0;
if(npar > 0)
6
←
Assuming 'npar' is > 0→
7
←
Taking true branch→
{
  myword = new TransferWord *[npar];
8
←
Memory is allocated→
  std::fill(myword, myword+npar, (TransferWord *)(0));
  for (auto i : children(localroot)) {
    if (idx8.1
'idx' is < 'npar'
 >= npar) {
9
←
Taking false branch→
10
←
Assuming 'idx' is >= 'npar'→
11
←
Taking true branch→
      cerr << "Error: processCallMacro() number of arguments >= npar at line " << i->line << endl;
12
←
Potential leak of memory pointed to by 'myword'
      return;
    }
    int pos = atoi((const char *) i->properties->children->content)-1;
    myword[idx] = word[pos];

    idx++;
  }
}

swap(myword, word);
swap(npar, lword);

for (auto i : children(macro)) {
  processInstruction(i);
}

swap(myword, word);
swap(npar, lword);

delete[] myword;
788}

790TransferToken &
791Transfer::readToken(InputFile& in)
792{
if(!input_buffer.isEmpty())
{
  return input_buffer.next();
}

UString content;
while(true)
{
  UChar32 val = in.get();
  if(in.eof() || (val == 0 && internal_null_flush))
  {
    in_wblank = false;
    return input_buffer.add(TransferToken(content, tt_eof));
  }
  if(in_wblank)
  {
    content = "[["_u;
    content += val;

    while(true)
    {
      UChar32 val3 = in.get();
      if(val3 == '\\')
      {
        content += '\\';
        content += in.get();
      }
      else if(val3 == '$') //[[..]]^..$ is the LU
      {
        in_wblank = false;
        return input_buffer.add(TransferToken(content, tt_word));
      }
      else if(val3 == '\0' && null_flush)
      {
        in_wblank = false;
        u_fflushu_fflush_72(output);
      }
      else
      {
        content += val3;
      }
    }
  }
  if(val == '\\')
  {
    content += '\\';
    content += in.get();
  }
  else if(val == '[')
  {
    content += '[';
    while(true)
    {
      UChar32 val2 = in.get();
      if(val2 == '\\')
      {
        content += '\\';
        content += in.get();
      }
      else if(val2 == '[')
      { //wordbound blank
        in_wblank = true;
        content.pop_back();

        return input_buffer.add(TransferToken(content, tt_blank));
      }
      else if(val2 == ']')
      {
        content += ']';
        break;
      }
      else
      {
        content += val2;
      }
    }
  }
  else if(val == '$')
  {
    return input_buffer.add(TransferToken(content, tt_word));
  }
  else if(val == '^')
  {
    return input_buffer.add(TransferToken(content, tt_blank));
  }
  else if(val == '\0' && null_flush)
  {
    in_wblank = false;
    u_fflushu_fflush_72(output);
  }
  else
  {
    content += val;
  }
}
888}

890void
891Transfer::setTraceATT(bool trace)
892{
this->trace_att = trace;
894}

896void
897Transfer::tmp_clear()
898{
tmpblank.clear();
tmpword.clear();
variables = variable_defaults;
902}

904void
905Transfer::transfer_wrapper_null_flush(InputFile& in, UFILE* out)
906{
null_flush = false;
internal_null_flush = true;

while(!in.eof())
{
  tmp_clear();
  transfer(in, out);
  u_fputcu_fputc_72('\0', out);
  u_fflushu_fflush_72(out);
}

internal_null_flush = false;
null_flush = true;
920}

922void
923Transfer::transfer(InputFile& in, UFILE* out)
924{
if(getNullFlush())
{
  transfer_wrapper_null_flush(in, out);
}

unsigned int last = input_buffer.getPos();
unsigned int prev_last = last;
int lastrule_id = -1;
set<int> banned_rules;
in_wblank = false;

output = out;
ms.init(me->getInitial());

while(true)
{
  if(trace_att)
  {
    cerr << "Loop start " << endl;
    cerr << "ms.size: " << ms.size() << endl;

    cerr << "tmpword.size(): " << tmpword.size() << endl;
    for (unsigned int ind = 0; ind < tmpword.size(); ind++)
    {
      if(ind != 0)
      {
        cerr << " ";
      }
      cerr << *tmpword[ind];
    }
    cerr << endl;

    cerr << "tmpblank.size(): " << tmpblank.size() << endl;
    for (unsigned int ind = 0; ind < tmpblank.size(); ind++)
    {
      cerr << "'";
      cerr << *tmpblank[ind];
      cerr << "' ";
    }
    cerr << endl;

    cerr << "last: " << last << endl;
    cerr << "prev_last: " << prev_last << endl << endl;
  }

  if(ms.size() == 0)
  {
    if(lastrule != NULL__null)
    {
      int num_words_to_consume = applyRule();

      if(trace_att)
      {
        cerr << "num_words_to_consume: " << num_words_to_consume << endl;
      }

      //Consume all the words from the input which matched the rule.
      //This piece of code is executed unless the rule contains a "reject-current-rule" instruction
      if(num_words_to_consume < 0)
      {
        banned_rules.clear();
        input_buffer.setPos(last);
      }
      else if(num_words_to_consume > 0)
      {
        banned_rules.clear();
        if(prev_last >= input_buffer.getSize())
        {
          input_buffer.setPos(0);
        }
        else
        {
          input_buffer.setPos(prev_last+1);
        }
        int num_consumed_words = 0;
        while(num_consumed_words < num_words_to_consume && !input_buffer.isEmpty())
        {
          TransferToken& local_tt = input_buffer.next();
          if (local_tt.getType() == tt_word)
          {
            num_consumed_words++;
          }
        }
      }
      else
      {
        //Add rule to banned rules
        banned_rules.insert(lastrule_id);
        input_buffer.setPos(prev_last);
        input_buffer.next();
        last = input_buffer.getPos();
      }
      lastrule_id = -1;
    }
    else
    {
      if(tmpword.size() != 0)
      {
        if(trace_att)
        {
          cerr << "printing tmpword[0]" <<endl;
        }

        pair<UString, int> tr;
        UString tr_wblank;
        if(useBilingual && preBilingual == false)
        {
          if(isExtended && (*tmpword[0])[0] == '*') {
            tr = extended.biltransWithQueue((*tmpword[0]).substr(1), false);
            if(tr.first[0] == '@') {
              tr.first[0] = '*';
            } else {
              UString temp;
              temp += '%';
              temp.append(tr.first);
              temp.swap(tr.first);
            }
          } else {
            tr = fstp.biltransWithQueue(*tmpword[0], false);
          }
        }
        else if(preBilingual)
        {
          UString sl;
          UString tl;
          UString ref;
          UString wblank;
          UString cur;

          int seenSlash = 0;
          for(UString::const_iterator it = tmpword[0]->begin(); it != tmpword[0]->end(); it++)
          {
            if(*it == '\\') {
              cur.push_back(*it);
              it++;
              cur.push_back(*it);
              continue;
            }
            else if(*it == '[')
            {
              if(*(it+1) == '[') //wordbound blank
              {
                while(true)
                {
                  if(*it == '\\')
                  {
                    wblank.push_back(*it);
                    it++;
                    wblank.push_back(*it);
                  }
                  else if(*it == '^' && *(it-1) == ']' && *(it-2) == ']')
                  {
                    break;
                  }
                  else
                  {
                    wblank.push_back(*it);
                  }

                  it++;
                }
              }
              else
              {
                cur.push_back(*it);
              }
              continue;
            }
            else if(*it == '/')
            {
              ref.clear();
              switch (seenSlash) {
              case 0: cur.swap(sl); break;
              case 1: cur.swap(tl); break;
              default: cur.swap(ref);
              }
              seenSlash++;
              continue;
            }
            else if (*it == '<') {
              while (*it != '>') {
                cur.push_back(*it);
                if (*it == '\\') {
                  it++;
                  cur.push_back(*it);
                }
                it++;
              }
            }
            cur.push_back(*it);
          }
          if (!cur.empty()) {
            ref.clear();
            switch (seenSlash) {
            case 0: cur.swap(sl); break;
            case 1: cur.swap(tl); break;
            default: cur.swap(ref);
            }
          }
          //tmpword[0]->assign(sl);
          tr = pair<UString, int>(tl, false);
          tr_wblank = wblank;
          //cerr << "pb: " << *tmpword[0] << " :: " << sl << " >> " << tl << endl ;
        }
        else
        {
          tr = pair<UString, int>(*tmpword[0], 0);
        }

 if(tr.first.size() != 0) {
   if(defaultAttrs == lu) {
        if(tr.first[0] != '[' || tr.first[1] != '[') {
          u_fprintfu_fprintf_72(output, "%S^", tr_wblank.c_str());
        }
        u_fprintfu_fprintf_72(output, "%S$", tr.first.c_str());
      } else {
        if(tr.first[0] == '*') {
          u_fprintfu_fprintf_72(output, "^unknown<unknown>{%S^", tr_wblank.c_str());
        } else {
          u_fprintfu_fprintf_72(output, "^default<default>{%S^", tr_wblank.c_str());
        }
        u_fprintfu_fprintf_72(output, "%S$}$", tr.first.c_str());
      }
 }
 banned_rules.clear();
 tmpword.clear();
 input_buffer.setPos(last);
 input_buffer.next();
 prev_last = last;
 last = input_buffer.getPos();
 ms.init(me->getInitial());
}
else if(tmpblank.size() != 0)
{
        if(trace_att) {
          cerr << "printing tmpblank[0]" <<endl;
        }
        write(*tmpblank[0], output);
        tmpblank.clear();
        prev_last = last;
        last = input_buffer.getPos();
        ms.init(me->getInitial());
}
    }
  }
  int val = ms.classifyFinals(me->getFinals(), banned_rules);
  if(val != -1)
  {
    size_t lastrule_line = rule_lines[val-1];
    lastrule = rule_map[val-1];
    lastrule_id = val;
    last = input_buffer.getPos();
    last_lword = tmpword.size();

    if(trace) {
      cerr << endl << "apertium-transfer: Rule " << val << " line " << lastrule_line;
      for (auto& it : tmpword) {
        cerr << " " << *it;
      }
      cerr << endl;
    }
  }

  TransferToken &current = readToken(in);

  switch(current.getType())
  {
    case tt_word:
applyWord(current.getContent());
      tmpword.push_back(&current.getContent());
break;

    case tt_blank:
ms.step(' ');
tmpblank.push_back(&current.getContent());
break;

    case tt_eof:
if(tmpword.size() != 0)
{
 tmpblank.push_back(&current.getContent());
 ms.clear();
}
else
{
    write(current.getContent(), output);
 return;
}
break;

    default:
cerr << "Error: Unknown input token." << endl;
return;
  }
}
1220}

1222int
1223Transfer::applyRule()
1224{
int words_to_consume;
unsigned int limit = tmpword.size();
//cerr << "applyRule: " << tmpword.size() << endl;

for(unsigned int i = 0; i != limit; i++)
{
  if(i == 0)
  {
    word = new TransferWord *[limit];
    std::fill(word, word+limit, (TransferWord *)(0));
    lword = limit;
  }
  else
  {
    if(int(blank_queue.size()) < last_lword - 1)
    {
      blank_queue.push(*tmpblank[i-1]);
    }
  }

  if(useBilingual && preBilingual == false) {
    auto tr = fstp.biltransWithQueue(*tmpword[i], false);
    word[i] = new TransferWord(*tmpword[i], tr.first, ""_u, ""_u, tr.second);
  }
  else if(preBilingual) {
    UString sl;
    UString tl;
    UString ref;
    UString wblank;

    int seenSlash = 0;
    bool inTag = false;
    for(UString::const_iterator it = tmpword[i]->begin(); it != tmpword[i]->end(); it++)
    {
      if(*it == '\\')
      {
        if(seenSlash == 0)
        {
          sl.push_back(*it);
          it++;
          sl.push_back(*it);
        }
        else if(seenSlash == 1)
        {
          tl.push_back(*it);
          it++;
          tl.push_back(*it);
        }
        else
        {
          ref.push_back(*it);
          it++;
          ref.push_back(*it);
        }
        continue;
      }
      else if(*it == '[')
      {
        if(*(it+1) == '[') //wordbound blank
        {
          while(true) {
            if(*it == '\\') {
              wblank.push_back(*it);
              it++;
              wblank.push_back(*it);
            }
            else if(*it == '^' && *(it-1) == ']' && *(it-2) == ']') {
              break;
            }
            else {
              wblank.push_back(*it);
            }

            it++;
          }
        }
        else {
          if(seenSlash == 0)      sl.push_back(*it);
          else if(seenSlash == 1) tl.push_back(*it);
          else                   ref.push_back(*it);
        }
        continue;
      }

      if(*it == '/' && !inTag) {
        seenSlash++;

        ref.clear(); //word after last slash is ref
        continue;
      }
      // slashes in tags are accepted elsewhere in the pipe,
      // so don't split readings on them here
      else if (*it == '<') {
        inTag = true;
      }
      else if (*it == '>') {
        inTag = false;
      }
      if(seenSlash == 0)      sl.push_back(*it);
      else if(seenSlash == 1) tl.push_back(*it);
      else                   ref.push_back(*it);
    }
    word[i] = new TransferWord(sl, tl, ref, wblank, false);
  }
  else // neither useBilingual nor preBilingual (sl==tl)
  {
    word[i] = new TransferWord(*tmpword[i], *tmpword[i], ""_u, ""_u, false);
  }
}

words_to_consume = processRule(lastrule);
lastrule = NULL__null;

if(word)
{
  for(unsigned int i = 0; i != limit; i++)
  {
    delete word[i];
    word[i] = 0; // ToDo: That this changes things means there are much bigger problems elsewhere
  }
  delete[] word;
}
word = NULL__null;
tmpword.clear();
tmpblank.clear();
ms.init(me->getInitial());
return words_to_consume;
1352}

1354/* HERE */
1355void
1356Transfer::applyWord(UString const &word_str)
1357{
ms.step('^');

for(unsigned int i = 0, limit = word_str.size(); i < limit; i++)
{
  switch(word_str[i])
  {
    case '\\':
      i++;
      ms.step(u_toloweru_tolower_72(word_str[i]), any_char);
      break;

    case '[':
      if(word_str[i+1] == '[')
      {
        while(true)
        {
          if(word_str[i] == '\\')
          {
            i++;
          }
          else if(i >= 4)
          {
            if(word_str[i] == '^' && word_str[i-1] == ']' && word_str[i-2] == ']')
            {
              break;
            }
          }

          i++;
        }
      }
      else
      {
        ms.step(u_toloweru_tolower_72(word_str[i]), any_char);
      }
      break;

    case '/':
      i = limit;
      break;

    case '<':
for(unsigned int j = i+1; j != limit; j++)
{
 if(word_str[j] == '>')
 {
   int symbol = alphabet(word_str.substr(i, j-i+1));
   if(symbol)
   {
     ms.step(symbol, any_tag);
   }
   else
   {
     ms.step(any_tag);
   }
   i = j;
   break;
 }
}
break;

    default:
ms.step(u_toloweru_tolower_72(word_str[i]), any_char);
break;
  }
}
ms.step('$');
1425}

1427void
1428Transfer::setPreBilingual(bool value)
1429{
preBilingual = value;
1431}

1433bool
1434Transfer::getPreBilingual(void) const
1435{
return preBilingual;
1437}

1439void
1440Transfer::setUseBilingual(bool value)
1441{
useBilingual = value;
1443}

1445bool
1446Transfer::getUseBilingual(void) const
1447{
return useBilingual;
1449}

1451void
1452Transfer::setCaseSensitiveness(bool value)
1453{
fstp.setCaseSensitiveMode(value);
1455}