Exemple #1
0
AString ADVBConfig::ReplaceTerms(const AString& user, const AString& subitem, const AString& _str) const
{
	AString str = _str;
	int p1, p2;

	while (((p1 = str.Pos("{conf:")) >= 0) && ((p2 = str.Pos("}", p1)) >= 0)) {
		AString item = GetUserSubItemConfigItem(user, subitem, str.Mid(p1 + 6, p2 - p1 - 6));

		str = str.Left(p1) + item + str.Mid(p2 + 1);
	}

	return str;
}
Exemple #2
0
bool ADVBConfig::ReadReplacementsFile(std::vector<REPLACEMENT>& replacements, const AString& filename) const
{
	AStdFile fp;
	bool success = false;

	if (fp.open(filename)) {
		AString line;

		//printf("Reading replacements file '%s':", filename.str());

		while (line.ReadLn(fp) >= 0) {
			int p = 0;

			if ((line.Word(0)[0] != ';') && ((p = line.Pos("=")) >= 0)) {
				REPLACEMENT repl = {
					line.Left(p).Word(0).DeQuotify(),
					line.Mid(p + 1).Word(0).DeQuotify(),
				};

				//printf("Replacement: '%s' -> '%s'", repl.search.str(), repl.replace.str());

				replacements.push_back(repl);
			}
		}

		fp.close();

		success = true;
	}
	else logit("Failed to open replacements file '%s'", filename.str());

	return success;
}
Exemple #3
0
AString ADVBConfig::GetRelativePath(const AString& filename) const
{
	AString res;

	if (filename.StartsWith(GetRecordingsDir())) res = AString("/videos").CatPath(filename.Mid(GetRecordingsDir().len()));

	return res;
}
Exemple #4
0
bool ADVBPatterns::EnablePattern(const AString& user, const AString& pattern)
{
	ADVBLock lock("patterns");
	bool changed = false;

	if (pattern[0] == '#') {
		changed = UpdatePattern(user, pattern, pattern.Mid(1));
	}

	return changed;
}
/*--------------------------------------------------------------------------------*/
AString PostgresDatabase::ConvertSimpleType(const AString& ctype) const
{
	AString type;

	if      (ctype == "id")			  	type = "integer not null primary key";										                        // primary key id
	else if (ctype == "id64")			type = "bigint not null primary key";											                    // primary key id (64-bit)
	else if (ctype.Left(6) == "string") type.printf("varchar%s", ctype.Mid(6).SearchAndReplace("[", "(").SearchAndReplace("]", ")").str()); // string type / varchar
	else if (ctype == "datetime")     	type = "timestamp";
	else if (ctype == "float")        	type = "real";
	else if (ctype == "double")        	type = "real";
	else if (ctype == "short")        	type = "smallint";
	else if (ctype == "int64")        	type = "bigint";
	else if (ctype == "")			  	type = "integer";

	return type;
}
Exemple #6
0
static bool AddItem(const CXmlItem &item, CObjectVector<CFile> &files, int parent)
{
  if (!item.IsTag)
    return true;
  if (item.Name == "file")
  {
    CFile file;
    file.Parent = parent;
    parent = files.Size();
    file.Name = item.GetSubStringForTag("name");
    AString type = item.GetSubStringForTag("type");
    if (type == "directory")
      file.IsDir = true;
    else if (type == "file")
      file.IsDir = false;
    else
      return false;

    int dataIndex = item.FindSubTag("data");
    if (dataIndex >= 0 && !file.IsDir)
    {
      file.HasData = true;
      const CXmlItem &dataItem = item.SubItems[dataIndex];
      if (!ParseUInt64(dataItem, "size", file.Size))
        return false;
      if (!ParseUInt64(dataItem, "length", file.PackSize))
        return false;
      if (!ParseUInt64(dataItem, "offset", file.Offset))
        return false;
      file.Sha1IsDefined = ParseSha1(dataItem, "extracted-checksum", file.Sha1);
      // file.packSha1IsDefined = ParseSha1(dataItem, "archived-checksum",  file.packSha1);
      int encodingIndex = dataItem.FindSubTag("encoding");
      if (encodingIndex >= 0)
      {
        const CXmlItem &encodingItem = dataItem.SubItems[encodingIndex];
        if (encodingItem.IsTag)
        {
          AString s = encodingItem.GetPropertyValue("style");
          if (s.Length() >= 0)
          {
            AString appl = "application/";
            if (s.Left(appl.Length()) == appl)
            {
              s = s.Mid(appl.Length());
              AString xx = "x-";
              if (s.Left(xx.Length()) == xx)
              {
                s = s.Mid(xx.Length());
                if (s == "gzip")
                  s = METHOD_NAME_ZLIB;
              }
            }
            file.Method = s;
          }
        }
      }
    }

    file.CTime = ParseTime(item, "ctime");
    file.MTime = ParseTime(item, "mtime");
    file.ATime = ParseTime(item, "atime");
    files.Add(file);
  }
  for (int i = 0; i < item.SubItems.Size(); i++)
    if (!AddItem(item.SubItems[i], files, parent))
      return false;
  return true;
}
Exemple #7
0
void ADVBConfig::ListUsers(AList& list) const
{
	AHash 	 users(10);
	AList 	 userpatterns;
	AString  filepattern 	   = GetUserPatternsPattern();
	AString  filepattern_parsed = ParseRegex(filepattern);
	AString  _users             = GetConfigItem("users");
	AStdFile fp;
	uint_t   i, n = _users.CountColumns();

	//debug("Reading users from config %s\n", config.GetFilename().str());

	for (i = 0; i < n; i++) {
		AString user = _users.Column(i).Words(0);

		if (!users.Exists(user)) {
			users.Insert(user, 0);
			list.Add(new AString(user));
		}
	}

	if (fp.open(GetPatternsFile())) {
		AString line;

		while (line.ReadLn(fp) >= 0) {
			AString user;
			int p;

			if		((p = line.PosNoCase(" user:="******"user:=") == 0)        user = line.Mid(6).Word(0).DeQuotify();

			if (user.Valid() && !users.Exists(user)) {
				users.Insert(user, 0);
				list.Add(new AString(user));
			}
		}

		fp.close();
	}

	::CollectFiles(filepattern.PathPart(), filepattern.FilePart(), 0, userpatterns);

	const AString *file = AString::Cast(userpatterns.First());
	while (file) {
		AString   user;
		ADataList regions;

		if (MatchRegex(*file, filepattern_parsed, regions)) {
			const REGEXREGION *region = (const REGEXREGION *)regions[0];

			if (region) {
				user = file->Mid(region->pos, region->len);
				if (!users.Exists(user)) {
					users.Insert(user, 0);
					list.Add(new AString(user));
				}
			}
		}

		file = file->Next();
	}

	list.Sort(&AString::AlphaCompareCase);
}
void MotionDetector::Configure()
{
    AString nstr = AString("%").Arg(index);

    log.printf("%s[%u]: Reading new settings...\n", ADateTime().DateFormat("%Y-%M-%D %h:%m:%s.%S").str(), index);

    stream.Close();
    stream.SetUsernameAndPassword(GetSetting("username", "admin"),
                                  GetSetting("password", "arsebark"));

    AString camera = GetSetting("camera", "");
    log.printf("%s[%u]: Connecting to %s...\n", ADateTime().DateFormat("%Y-%M-%D %h:%m:%s.%S").str(), index, camera.str());
    if (!stream.OpenHost(camera)) {
        log.printf("%s[%u]: Failed to connect to %s...\n", ADateTime().DateFormat("%Y-%M-%D %h:%m:%s.%S").str(), index, camera.str());
    }

    imagedir  = GetSetting("imagedir", "/media/cctv");
    imagefmt  = GetSetting("filename", "%Y-%M-%D/%h/Image-{camera}-%Y-%M-%D-%h-%m-%s-%S");
    detimgdir = GetSetting("detimagedir");
    detimgfmt = GetSetting("detfilename", "%Y-%M-%D/%h/detection/Image-{camera}-%Y-%M-%D-%h-%m-%s-%S");
    detcmd    = GetSetting("detcommand", "");
    nodetcmd  = GetSetting("nodetcommand", "");
    coeff  	  = (double)GetSetting("coeff", "1.0e-3");
    avgfactor = (double)GetSetting("avgfactor", "1.0");
    sdfactor  = (double)GetSetting("sdfactor", "2.0");
    redscale  = (double)GetSetting("rscale", "1.0");
    grnscale  = (double)GetSetting("gscale", "1.0");
    bluscale  = (double)GetSetting("bscale", "1.0");
    threshold = (double)GetSetting("threshold", "3000.0");
    verbose   = (uint_t)GetSetting("verbose", "0");

    matmul 	  = 1.f;
    matwid 	  = mathgt = 0;

    AString _matrix = GetSetting("matrix", "");
    if (_matrix.Valid()) {
        uint_t row, nrows = _matrix.CountLines(";");
        uint_t col, ncols = 1;
        int    p;

        if ((p = _matrix.Pos("*")) >= 0) {
            AString mul = _matrix.Mid(p + 1);

            _matrix = _matrix.Left(p);

            if ((p = mul.Pos("/")) >= 0) {
                matmul = (float)mul.Left(p) / (float)mul.Mid(p + 1);
            }
            else matmul = (float)mul;
        }
        else if ((p = _matrix.Pos("/")) >= 0) {
            AString mul = _matrix.Mid(p + 1);

            _matrix = _matrix.Left(p);

            matmul = 1.f / (float)mul;
        }

        for (row = 0; row < nrows; row++) {
            uint_t n = _matrix.Line(row, ";").CountLines(",");
            ncols = MAX(ncols, n);
        }

        nrows |= 1;
        ncols |= 1;

        matrix.resize(nrows * ncols);
        for (row = 0; row < nrows; row++) {
            AString line = _matrix.Line(row,";");

            for (col = 0; col < ncols; col++) matrix[col + row * ncols] = (float)line.Line(col, ",");
        }

        matwid = ncols;
        mathgt = nrows;

#if 0
        printf("Matrix is %u x %u:\n", matwid, mathgt);
        for (row = 0; row < nrows; row++) {
            for (col = 0; col < ncols; col++) printf("%8.3f", matrix[col + row * ncols]);
            printf("\n");
        }
        printf("Multiplier %0.6f\n", matmul);
#endif
    }
    else matrix.resize(0);
}
Exemple #9
0
bool DecodeXML(AStructuredNode& root, const AString& str)
{
	AStructuredNode *pNode = &root;
	AKeyValuePair   *pAttr;
	ADataList       stack;
	uint_t p1 = 0, p2;
	
	while (IsXMLWhiteSpace(str[p1])) p1++;
	while (!HasQuit() && pNode && (str[p1] == '<')) {
		bool popnode = false;

		p1++;
		if (str[p1] == '/') {
			p1++;
			if ((pNode != &root) && ((p2 = FindXMLMarker(str, p1)) > p1)) {
				uint_t p3 = p1;
				
				if (IsSymbolStart(str[p1])) p1++;
				while (IsXMLNameChar(str[p1])) p1++;

				AString name = str.Mid(p3, p1 - p3);
				if (name == pNode->Key) {
					if (debug_decode) debug("Closing node '%s'\n", pNode->Key.str());
					popnode = true;
					p1 = p2 + 1;
				}
				else {
					debug("Unknown close object '%s' at %u\n", name.str(), p1);
					break;
				}
			}
			else {
				debug("Unknown close marker at %u\n", p1);
				break;
			}
		}
		else if (str.Mid(p1, 3) == "!--") {
			if ((p2 = str.Pos("-->", p1 + 3)) > p1) p1 = p2 + 2;
			else {
				debug("Unterminated comment marker at %u\n", p1);
				break;
			}
		}
		else if ((p2 = FindXMLMarker(str, p1)) > p1) {
			if (pNode) stack.Push((void *)pNode);
			
			if ((pNode = new AStructuredNode) != NULL) {
				uint_t p3 = p2;
				bool   complete = ((str[p3 - 1] == '/') || ((str[p1] == '?') && (str[p3 - 1] == '?')));
				
				if (complete) p3--;

				complete |= (str[p1] == '!');

				if ((str[p1] == '?') || (str[p1] == '!')) pNode->SetType(str[p1++]);
				
				while (IsXMLWhiteSpace(str[p1])) p1++;

				uint_t p4 = p1;
				if (IsSymbolStart(str[p1])) p1++;
				while (IsXMLNameChar(str[p1])) p1++;

				pNode->Key = str.Mid(p4, p1 - p4).DeHTMLify();
				if (debug_decode) debug("Created new node '%s' (%s)\n", pNode->Key.str(), complete ? "complete" : "open");

				while (IsXMLWhiteSpace(str[p1])) p1++;

				while (p1 < p3) {
					p4 = p1;
					if (IsSymbolStart(str[p1])) p1++;
					while (IsXMLNameChar(str[p1])) p1++;
					uint_t p5 = p1;
					
					while (IsXMLWhiteSpace(str[p1])) p1++;
					if (str[p1] == '=') p1++;
					while (IsXMLWhiteSpace(str[p1])) p1++;

					int quote = 0;
					if (IsQuoteChar(str[p1])) quote = str[p1++];

					uint_t p6 = p1;
					while (str[p1] && ((quote && (str[p1] != quote)) ||
									   (!quote && !IsXMLWhiteSpace(str[p1])))) p1++;
					uint_t p7 = p1;

					if (quote && (str[p1] == quote)) p1++;
					while (IsXMLWhiteSpace(str[p1])) p1++;

					if ((p5 > p4) && ((pAttr = new AKeyValuePair) != NULL)) {
						pAttr->Key   = str.Mid(p4, p5 - p4).DeHTMLify();
						pAttr->Value = str.Mid(p6, p7 - p6).DeHTMLify();
						pNode->AddAttribute(pAttr);
						if (debug_decode) debug("Added attribute '%s'='%s' to '%s'\n", pAttr->Key.str(), pAttr->Value.str(), pNode->Key.str());
					}
					else break;
				}
				
				AStructuredNode *pParent = (AStructuredNode *)stack.Last();
				if (pParent) pParent->AddChild(pNode);

				p2++;
				while (IsXMLWhiteSpace(str[p2])) p2++;

				p3 = p1 = p2;
				while (str[p2] && (str[p2] != '<')) {
					p2++;
					if (!IsXMLWhiteSpace(str[p2 - 1])) p3 = p2;
				}
				if (p3 > p1) {
					pNode->Value = str.Mid(p1, p3 - p1).DeHTMLify();
					if (debug_decode) debug("Set value of '%s' to '%s'\n", pNode->Key.str(), pNode->Value.str());
				}
				p1 = p2;

				popnode = complete;
			}
		}

		if (popnode) {
			if (stack.Count()) {
				pNode = (AStructuredNode *)stack.EndPop();
				if (debug_decode) debug("Back to node '%s'\n", pNode->Key.str());
			}
			else {
				debug("Stack empty at %u\n", p1);
				break;
			}
		}
		
		while (IsXMLWhiteSpace(str[p1])) p1++;
	}

	if (stack.Count()) debug("Unterminated XML entries at %u\n", p1);
	if (!pNode)		   debug("Extra XML termination at %u\n", p1);
	
	return (!str[p1] && (pNode == &root));
}
Exemple #10
0
AString ADVBPatterns::ParsePattern(const AString& _line, PATTERN& pattern, const AString& user)
{
	const ADVBConfig& config = ADVBConfig::Get();
	ADataList& list   = pattern.list;
	AString&   errors = pattern.errors;
	AString    line   = config.ReplaceTerms(user, _line);
	TERM   *term;
	uint_t i;

	pattern.exclude    = false;
	pattern.enabled    = true;
	pattern.scorebased = false;
	pattern.pri        = 0;
	pattern.user       = user;
	pattern.pattern    = line;

	if (pattern.user.Valid()) {
		pattern.pri = (int)config.GetUserConfigItem(pattern.user, "pri");
	}

	list.DeleteList();
	list.SetDestructor(&__DeleteTerm);

	i = 0;
	while (IsWhiteSpace(line[i])) i++;
	if (line[i] == '#') {
		pattern.enabled = false;
		i++;
	}
	else if (line[i] == ';') {
		return errors;
	}

	while (IsWhiteSpace(line[i])) i++;

	if (line[i]) {
		while (line[i] && errors.Empty()) {
			if (!IsSymbolStart(line[i])) {
				errors.printf("Character '%c' (at %u) is not a legal field start character (term %u)", line[i], i, list.Count() + 1);
				break;
			}

			uint_t fieldstart = i++;
			while (IsSymbolChar(line[i])) i++;
			AString field = line.Mid(fieldstart, i - fieldstart).ToLower();

			while (IsWhiteSpace(line[i])) i++;

			if (field == "exclude") {
				pattern.exclude = true;
				continue;
			}

			const FIELD *fieldptr = (const FIELD *)ADVBProg::fieldhash.Read(field);
			if (!fieldptr) {
				uint_t nfields;
				const FIELD *fields = ADVBProg::GetFields(nfields);

				errors.printf("'%s' (at %u) is not a valid search field (term %u), valid search fields are: ", field.str(), fieldstart, list.Count() + 1);
				for (i = 0; i < nfields; i++) {
					const FIELD& field = fields[i];

					if (i) errors.printf(", ");
					errors.printf("'%s'", field.name);
				}
				break;
			}

			uint_t opstart = i;

			const char *str = line.str() + i;
			bool isassign = fieldptr->assignable;
			uint_t j;
			uint_t opindex = 0, opcode = Operator_EQ;
			for (j = 0; j < NUMBEROF(operators); j++) {
				if (((isassign == operators[j].assign) ||
					 (isassign && !operators[j].assign)) &&
					(operators[j].fieldtypes & (1U << fieldptr->type)) &&
					(strncmp(str, operators[j].str, operators[j].len) == 0)) {
					i      += operators[j].len;
					opindex = j;
					opcode  = operators[j].opcode;
					break;
				}
			}

			while (IsWhiteSpace(line[i])) i++;

			AString value;
			bool    implicitvalue = false;
			if (j == NUMBEROF(operators)) {
				if (!line[i] || IsSymbolStart(line[i])) {
					if (fieldptr->assignable) {
						switch (fieldptr->type) {
							case FieldType_string:
								break;

							case FieldType_date:
								value = "now";
								break;

							default:
								value = "1";
								break;
						}

						opcode = Operator_Assign;
					}
					else opcode = Operator_NE;

					for (j = 0; j < NUMBEROF(operators); j++) {
						if ((opcode == operators[j].opcode) &&
							((isassign == operators[j].assign) ||
							 (isassign && !operators[j].assign)) &&
							(operators[j].fieldtypes & (1U << fieldptr->type))) {
							opindex = j;
							break;
						}
					}

					implicitvalue = true;
				}
				else {
					errors.printf("Symbols at %u do not represent a legal operator (term %u), legal operators for the field '%s' are: ", opstart, list.Count() + 1, field.str());

					bool flag = false;
					for (j = 0; j < NUMBEROF(operators); j++) {
						if (((isassign == operators[j].assign) ||
							 (isassign && !operators[j].assign)) &&
							(operators[j].fieldtypes & (1U << fieldptr->type))) {
							if (flag) errors.printf(", ");
							errors.printf("'%s'", operators[j].str);
							flag = true;
						}
					}
					break;
				}
			}

			if (!implicitvalue) {
				char quote = 0;
				if (IsQuoteChar(line[i])) quote = line[i++];

				uint_t valuestart = i;
				while (line[i] && ((!quote && !IsWhiteSpace(line[i])) || (quote && (line[i] != quote)))) {
					if (line[i] == '\\') i++;
					i++;
				}

				value = line.Mid(valuestart, i - valuestart).DeEscapify();

				if (quote && (line[i] == quote)) i++;

				while (IsWhiteSpace(line[i])) i++;
			}

			bool orflag = false;
			if ((line.Mid(i, 2).ToLower() == "or") && IsWhiteSpace(line[i + 2])) {
				orflag = true;
				i += 2;

				while (IsWhiteSpace(line[i])) i++;
			}
			else if ((line[i] == '|') && IsWhiteSpace(line[i + 1])) {
				orflag = true;
				i += 1;

				while (IsWhiteSpace(line[i])) i++;
			}

			if ((term = new TERM) != NULL) {
				term->data.start   = fieldstart;
				term->data.length  = i - fieldstart;
				term->data.field   = fieldptr - ADVBProg::fields;
				term->data.opcode  = opcode;
				term->data.opindex = opindex;
				term->data.value   = value;
				term->data.orflag  = (orflag && !RANGE(opcode, Operator_First_Assignable, Operator_Last_Assignable));
				term->field    	   = fieldptr;
				term->datetype 	   = DateType_none;

				switch (term->field->type) {
					case FieldType_string:
#if DVBDATVERSION > 1
						if (fieldptr->offset == ADVBProg::GetTagsDataOffset()) {
							value = "|" + value + "|";
						}
#endif
						
						if ((opcode & ~Operator_Inverted) == Operator_Regex) {
							AString regexerrors;
							AString rvalue;

							rvalue = ParseRegex(value, regexerrors);
							if (regexerrors.Valid()) {
								errors.printf("Regex error in value '%s' (term %u): %s", value.str(), list.Count() + 1, regexerrors.str());
							}

							value = rvalue;
						}
						term->value.str = value.Steal();
						break;

					case FieldType_date: {
						ADateTime dt;
						uint_t specified;

						dt.StrToDate(value, ADateTime::Time_Relative_Local, &specified);

						//debug("Value '%s', specified %u\n", value.str(), specified);

						if (!specified) {
							errors.printf("Failed to parse date '%s' (term %u)", value.str(), list.Count() + 1);
							break;
						}
						else if (((specified == ADateTime::Specified_Day) && (stricmp(term->field->name, "on") == 0)) ||
								 (stricmp(term->field->name, "day") == 0)) {
							//debug("Date from '%s' is '%s' (week day only)\n", value.str(), dt.DateToStr().str());
							term->value.u64 = dt.GetWeekDay();
							term->datetype  = DateType_weekday;
						}
						else if (specified & ADateTime::Specified_Day) {
							specified |= ADateTime::Specified_Date;
						}

						if (term->datetype == DateType_none) {
							specified &= ADateTime::Specified_Date | ADateTime::Specified_Time;

							if (specified == (ADateTime::Specified_Date | ADateTime::Specified_Time)) {
								//debug("Date from '%s' is '%s' (full date and time)\n", value.str(), dt.DateToStr().str());
								term->value.u64 = (uint64_t)dt;
								term->datetype  = DateType_fulldate;
							}
							else if (specified == ADateTime::Specified_Date) {
								//debug("Date from '%s' is '%s' (date only)\n", value.str(), dt.DateToStr().str());
								term->value.u64 = dt.GetDays();
								term->datetype  = DateType_date;
							}
							else if (specified == ADateTime::Specified_Time) {
								//debug("Date from '%s' is '%s' (time only)\n", value.str(), dt.DateToStr().str());
								term->value.u64 = dt.GetMS();
								term->datetype  = DateType_time;
							}
							else {
								errors.printf("Unknown date specifier '%s' (term %u)", value.str(), list.Count() + 1);
							}
						}
						break;
					}

					case FieldType_span:
					case FieldType_age: {
						ADateTime dt;
						//ADateTime::EnableDebugStrToDate(true);
						term->value.u64 = (uint64_t)ADateTime(value, ADateTime::Time_Absolute);
						//ADateTime::EnableDebugStrToDate(false);
						break;
					}

					case FieldType_uint32_t:
					case FieldType_external_uint32_t:
						term->value.u32 = (uint32_t)value;
						break;

					case FieldType_sint32_t:
					case FieldType_external_sint32_t:
						term->value.s32 = (sint32_t)value;
						break;

					case FieldType_uint16_t:
						term->value.u16 = (uint16_t)value;
						break;

					case FieldType_sint16_t:
						term->value.s16 = (sint16_t)value;
						break;

					case FieldType_uint8_t:
						term->value.u8 = (uint8_t)(uint16_t)value;
						break;

					case FieldType_sint8_t:
						term->value.s8 = (sint8_t)(sint16_t)value;
						break;

					case FieldType_flag...FieldType_lastflag:
						term->value.u8 = ((uint32_t)value != 0);
						//debug("Setting test of flag to %u\n", (uint_t)term->value.u8);
						break;

					case FieldType_prog: {
						ADVBProg *prog;

						if ((prog = new ADVBProg) != NULL) {
							if (prog->Base64Decode(value)) {
								term->value.prog = prog;
							}
							else {
								errors.printf("Failed to decode base64 programme ('%s') for %s at %u (term %u)", value.str(), field.str(), fieldstart, list.Count() + 1);
								delete prog;
							}
						}
						else {
							errors.printf("Failed to allocate memory for base64 programme ('%s') for %s at %u (term %u)", value.str(), field.str(), fieldstart, list.Count() + 1);
						}
						break;
					}

					default:
						errors.printf("Unknown field '%s' type (%u) (term %u)", field.str(), (uint_t)term->field->type, list.Count() + 1);
						break;
				}

				//debug("term: field {name '%s', type %u, assignable %u, offset %u} type %u dateflags %u value '%s'\n", term->field->name, (uint_t)term->field->type, (uint_t)term->field->assignable, term->field->offset, (uint_t)term->data.opcode, (uint_t)term->dateflags, term->value.str);

				if (errors.Empty()) {
					pattern.scorebased |= (term->field->offset == ADVBProg::GetScoreDataOffset());
					list.Add((uptr_t)term);
				}
				else {
					__DeleteTerm((uptr_t)term, NULL);
					break;
				}
			}
		}
	}