bool FrLocateFileSetFallback(const char *directory, bool strip_tail)
{
FrFree(fallback_dir) ;
if (strip_tail)
{
fallback_dir = FrFileDirectory(directory) ;
if (fallback_dir)
{
size_t len = strlen(fallback_dir) ;
if (len > 0 && fallback_dir[len-1] == '/')
fallback_dir[len-1] = '\0' ;
}
if (!fallback_dir || !*fallback_dir ||
(fallback_dir[0] == '.' && fallback_dir[1] == '\0'))
{
FrFree(fallback_dir) ;
char cwd[5000] ;
if (getcwd(cwd,sizeof(cwd)))
fallback_dir = FrDupString(cwd) ;
}
}
else
fallback_dir = FrDupString(directory) ;
return fallback_dir != 0 ;
}
FrTextSpans::FrTextSpans(const FrTextSpans *old)
{
clear() ;
if (old)
{
m_text = FrDupString(old->m_text) ;
setPositionMap() ;
if (m_text && m_positions)
{
FrList *fields = old->m_metadata.fieldNames() ;
while (fields)
{
FrSymbol *key = (FrSymbol*)poplist(fields) ;
setMetaData(key,old->metaData(key)) ;
}
}
else
{
FrFree(m_text) ; m_text = 0 ;
FrFree(m_positions) ; m_positions = 0 ;
m_textlength = 0 ;
}
}
return ;
}
void FrFeatureVectorMap::init(const FrFeatureVectorMap *oldmap)
{
m_self = 0 ;
init() ;
if (oldmap && oldmap->numFeatures() > 0)
{
m_featurecount = oldmap->numFeatures() ;
m_alloccount = oldmap->m_alloccount ;
m_names = FrNewN(char*,m_alloccount) ;
m_sort_order = FrNewN(unsigned,m_alloccount) ;
if (m_names && m_sort_order)
{
// copy the feature names from the old map
for (size_t i = 0 ; i < numFeatures() ; i++)
{
m_names[i] = FrDupString(oldmap->m_names[i]) ;
m_sort_order[i] = oldmap->m_sort_order[i] ;
}
}
else
{
FrFree(m_names) ;
m_names = 0 ;
FrFree(m_sort_order) ;
m_sort_order = 0 ;
FrNoMemory("while copying feature map") ;
m_featurecount = m_alloccount = 0 ;
}
}
void FramepaC_set_db_dir(const char *dir)
{
FrFree(db_directory) ;
if (!dir)
dir = "." ;
db_directory = FrDupString(dir) ;
return ;
}
char *FrTextSpan::initialText() const
{
const FrObject *txt = getMetaData(init_text_tag) ;
if (txt && txt->consp() && ((FrList*)txt)->first() &&
((FrList*)txt)->first()->stringp())
txt = ((FrList*)txt)->first() ;
const char *printed = FrPrintableName(txt) ;
return printed ? FrDupString(printed) : originalText() ;
}
void FrTextSpan::updateText(char *new_text, bool copy_text)
{
FrSymbol *symINIT = FrSymbolTable::add(init_text_tag) ;
if (!getMetaData(symINIT))
{
char *txt = getText() ;
setMetaData(symINIT,new FrString(txt,strlen(txt),1,false),false) ;
}
FrFree(m_text) ;
m_text = copy_text ? FrDupString(new_text) : new_text ;
return ;
}
void FrTextSpans::makeWordSpans(const char *text, FrCharEncoding enc,
const char *word_delim)
{
m_text = FrDupString(text) ;
if (m_text)
{
if (!setPositionMap())
{
m_textlength = 0 ;
return ;
}
char *canon = FrCanonicalizeSentence(m_text,enc,false,word_delim) ;
if (canon && *canon)
{
m_spancount = 1 ;
for (char *cptr = canon ; *cptr ; cptr++)
{
if (' ' == *cptr)
m_spancount++ ;
}
m_spans = FrNewN(FrTextSpan,m_spancount) ;
if (m_spans)
{
size_t tpos = 0 ;
size_t cpos = 0 ;
size_t start = 0 ;
size_t end = 0 ;
for (size_t i = 0 ; i < m_spancount ; i++)
{
// scan over the nonwhitespace chars at the current location
for ( ; canon[cpos] && canon[cpos] != ' ' ; cpos++)
{
tpos++ ;
end++ ; // counts toward m_positions index
}
// skip over any trailing whitespace
while (m_text[tpos] && Fr_isspace(m_text[tpos]))
tpos++ ;
if (canon[cpos] == ' ')
cpos++ ;
m_spans[i].init(start,end-1,DEFAULT_SCORE,DEFAULT_WEIGHT,
0,this) ;
m_sorted = false ;
start = end ;
}
}
}
FrFree(canon) ;
}
return ;
}
void FrTextSpans::makeWordSpans(const FrList *defn)
{
FrString *concat = new FrString(defn) ;
m_text = FrDupString(concat->stringValue()) ;
free_object(concat) ;
if (setPositionMap())
{
m_spancount = defn->simplelistlength() ;
m_spans = FrNewN(FrTextSpan,m_spancount) ;
if (!m_spans)
{
m_spancount = 0 ;
return ;
}
size_t spannum = 0 ;
size_t start = 0 ;
size_t end = 0 ;
for ( ; defn ; defn = defn->rest())
{
FrObject *def = defn->first() ;
if (def && def->structp())
{
addMetaData((FrStruct*)def) ;
continue ;
}
const char *item = FrPrintableName(def) ;
if (!item)
item = "" ;
for (const char *i = item ; *i ; i++)
{
if (!Fr_isspace(*i))
end++ ;
}
if (end > 0)
m_spans[spannum++].init(start,end-1,DEFAULT_SCORE,DEFAULT_WEIGHT,
item,this) ;
m_sorted = false ;
start = end ;
}
m_spancount = spannum ;
}
return ;
}
static void expected_right_paren(const FrList *list)
{
size_t len = list->listlength() ;
FrObject *listhead = list->subseq(0,5) ;
char *printed = listhead->print() ;
free_object(listhead) ;
if (!printed)
printed = FrDupString("") ;
const char *cont = "" ;
if (len > 6)
{
cont = " ..." ;
strchr(printed,'\0')[-1] = '\0' ;
}
FrWarningVA("malformed list (expected right parenthesis),\n\tread %s%s",
printed,cont) ;
FrFree(printed) ;
return ;
}
void FrTextSpans::parseSpans(const FrList *spans, size_t numstrings)
{
for (const FrList *sp = spans ; sp ; sp = sp->rest())
{
const FrObject *item = sp->first() ;
if (item && (item->stringp() || item->symbolp()))
{
m_text = FrDupString(FrPrintableName(item)) ;
if (m_text && setPositionMap())
break ;
return ;
}
}
m_spancount = spans->simplelistlength() - numstrings ;
m_spans = FrNewN(FrTextSpan,m_spancount) ;
if (!m_spans)
{
m_spancount = 0 ;
return ;
}
size_t count = 0 ;
for ( ; spans ; spans = spans->rest())
{
FrList *span = (FrList*)spans->first() ;
if (!span)
continue ;
if (span->consp() && m_spans[count].parse(span,this))
{
count++ ;
m_sorted = false ;
}
else if (span->structp())
{
FrStruct *meta = (FrStruct*)span ;
if (meta->typeName() &&
Fr_stricmp(FrPrintableName(meta->typeName()),"META") == 0)
addMetaData(meta) ;
}
}
m_spancount = count ;
return ;
}
void FrTextSpan::init(size_t sp_start, size_t sp_end, double sc, double wt,
const char *txt, FrTextSpans *spans)
{
if (spans)
{
if (sp_start >= spans->textLength())
sp_start = spans->textLength() - 1 ;
if (sp_end >= spans->textLength())
sp_end = spans->textLength() - 1 ;
}
if (sp_end < sp_start)
sp_end = sp_start ;
if (wt < 0.0)
wt = 0.0 ;
m_start = sp_start ;
m_end = sp_end ;
m_score = sc ;
m_weight = wt ;
m_text = FrDupString(txt) ;
m_spans = spans ;
m_metadata = 0 ;
return ;
}
static bool completion_for(const FrSymbol *name, FrObject * /*info*/, va_list args)
{
//HashEntryVFrame* entry = (HashEntryVFrame*)info ;
FrVarArg(const char *,prefix) ;
FrVarArg(size_t,prefixlen) ;
FrVarArg(char**,match) ;
if (name)
{
const char *namestr = name->symbolName() ;
if (prefixlen == 0 || memcmp(prefix,namestr,prefixlen) == 0)
{
if (*match)
{
size_t i ;
for (i = 0 ; (*match)[i] && (*match)[i] == namestr[i] ; ++i)
;
(*match)[i] = '\0' ;
}
else
*match = FrDupString(namestr) ;
}
}
return true ;
}
char *FrTextSpan::getText() const
{
return m_text ? FrDupString(m_text) : originalText() ;
}
static const char *re_match(const FrRegExElt *re, const char *candidate,
size_t min_reps, size_t &max_reps,
char *&match, const char *matchbuf_end,
char **groups, size_t num_groups)
{
assertq(re != 0 && match != 0 && matchbuf_end != 0) ;
switch (re->reType())
{
case FrRegExElt::End: // match end of word
if (*candidate)
{
max_reps = 0 ; // uh oh, not at end of word....
return 0 ;
}
else
{
max_reps = 1 ;
return candidate ;
}
case FrRegExElt::Char:
{
char c = Fr_toupper(re->getChar()) ;
size_t i ;
for (i = 0 ; i < max_reps ; i++)
{
if (Fr_toupper(*candidate) != c)
break ;
if (match < matchbuf_end)
*match++ = *candidate ;
candidate++ ;
}
max_reps = i ;
if (i >= min_reps )
return candidate ;
else
return 0 ;
}
case FrRegExElt::CharSet:
{
const char *set = re->getCharSet() ;
if (!set)
{
max_reps = 0 ;
return 0 ;
}
size_t i ;
for (i = 0 ; i < max_reps && *candidate ; i++)
{
if (!set[*(unsigned char*)candidate])
break ;
if (match < matchbuf_end)
*match++ = *candidate ;
candidate++ ;
}
max_reps = i ;
if (i >= min_reps)
return candidate ;
else
return 0 ;
}
case FrRegExElt::String:
{
const char *string = re->getString() ;
size_t len = re->stringLength() ;
if (!string)
{
max_reps = 0 ;
return 0 ;
}
size_t i ;
for (i = 0 ; i < max_reps ; i++)
{
if (Fr_memicmp(candidate,string,len) != 0)
break ;
const char *tstr = string+len+1 ;
size_t tlen = strlen(tstr) ;
if (match+tlen < matchbuf_end)
{
memcpy(match,tstr,tlen) ;
match += tlen ;
}
candidate += len ;
}
max_reps = i ;
if (i >= min_reps)
return candidate ;
else
return 0 ;
}
case FrRegExElt::Alt:
{
FrRegExElt **alts = re->getAlternatives() ;
char *matchbuf = match ;
const char *end = re_match_alt(alts,candidate,min_reps,max_reps,
match,matchbuf_end,groups,num_groups) ;
if (max_reps >= min_reps)
{
int group_num = re->groupNumber() ;
if (end && group_num >= 0 && group_num < (int)num_groups)
{
// since the r.e. compiler ensures that only alternations can
// be used for grouping, we can get away with only recording
// groupings right here
*match = '\0' ;
FrFree(groups[group_num]) ;
groups[group_num] = FrDupString(matchbuf) ;
}
return end ;
}
else
return 0 ;
}
case FrRegExElt::Class:
{
const char *end = re_match_class(re,candidate,min_reps,max_reps,
match,matchbuf_end,groups,
num_groups) ;
return (max_reps >= min_reps) ? end : 0 ;
}
case FrRegExElt::Accept:
return strchr(candidate,'\0') ;
default:
max_reps = 0 ;
FrMissedCase("re_match") ;
return 0 ;
}
}
