int CALLBACK CSubtitleDlDlg::DefSortCompare(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
{
PDEFPARAMSORT defps = reinterpret_cast<PDEFPARAMSORT>(lParamSort);
TCHAR left[MAX_PATH] = _T("");
TCHAR right[MAX_PATH] = _T("");
// sort by language first
ListView_GetItemText(defps->m_hWnd, lParam1, COL_LANGUAGE, left, sizeof(left));
ListView_GetItemText(defps->m_hWnd, lParam2, COL_LANGUAGE, right, sizeof(right));
// user-provided sort order
int lpos, rpos;
if (!defps->m_langPos.Lookup(left, lpos)) {
lpos = INT_MAX;
}
if (!defps->m_langPos.Lookup(right, rpos)) {
rpos = INT_MAX;
}
if (lpos < rpos) {
return -1;
} else if (lpos > rpos) {
return 1;
} else if (lpos == INT_MAX && rpos == INT_MAX) {
// lexicographical order
int res = _tcscmp(left, right);
if (res != 0) {
return res;
}
}
// sort by filename
ListView_GetItemText(defps->m_hWnd, lParam1, COL_FILENAME, left, sizeof(left));
ListView_GetItemText(defps->m_hWnd, lParam2, COL_FILENAME, right, sizeof(right));
size_t lmatch = StrMatch(defps->m_filename, left);
size_t rmatch = StrMatch(defps->m_filename, right);
// sort by matching character number
if (lmatch > rmatch) {
return -1;
} else if (lmatch < rmatch) {
return 1;
}
// prefer shorter names
size_t llen = _tcslen(left);
size_t rlen = _tcslen(right);
if (llen < rlen) {
return -1;
} else if (llen > rlen) {
return 1;
}
return 0;
}
/*****************************************************************************
*
* Boolean AsnLexReadBoolean(aip, atp)
* expects a BOOLEAN next
* assumes none of it has already been read
* does not advance to next token
* atp points to the definition of this BOOLEN
*
*****************************************************************************/
NLM_EXTERN Boolean AsnLexReadBoolean (AsnIoPtr aip, AsnTypePtr atp)
{
AsnLexWord(aip); /* read the boolean */
if (StrMatch("TRUE", aip->word, aip->wordlen))
return TRUE;
else if (StrMatch("FALSE", aip->word, aip->wordlen))
return FALSE;
AsnIoErrorMsg(aip, 42, AsnErrGetTypeName(atp->name), aip->linenumber);
return FALSE; /* just for lint */
}
SEXP do_palette(SEXP call, SEXP op, SEXP args, SEXP rho)
{
SEXP val, ans;
unsigned int color[COLOR_TABLE_SIZE];
int i, n;
checkArity(op,args);
/* Record the current palette */
PROTECT(ans = allocVector(STRSXP, R_ColorTableSize));
for (i = 0; i < R_ColorTableSize; i++)
SET_STRING_ELT(ans, i, mkChar(col2name(R_ColorTable[i])));
val = CAR(args);
if (!isString(val)) errorcall(call, _("invalid argument type"));
if ((n=length(val)) == 1) {
if (StrMatch("default", CHAR(STRING_ELT(val, 0))))
setpalette(DefaultPalette);
else errorcall(call, _("unknown palette (need >= 2 colors)"));
}
else if (n > 1) {
if (n > COLOR_TABLE_SIZE)
errorcall(call, _("maximum number of colors exceeded"));
for (i = 0; i < n; i++)
color[i] = char2col(CHAR(STRING_ELT(val, i)));
for (i = 0; i < n; i++)
R_ColorTable[i] = color[i];
R_ColorTableSize = n;
}
UNPROTECT(1);
return ans;
}
unsigned int attribute_hidden name2col(const char *nm)
{
int i;
if(strcmp(nm, "NA") == 0 || strcmp(nm, "transparent") == 0)
/*
* Paul 01/07/04 (2004-07-01?)
*
* Used to be set to NA_INTEGER.
*
* Now set to fully transparent white.
*
* In some cases, fully transparent gets caught by
* the graphics engine and no drawing occurs, but
* in other cases, transparent colours are passed to devices.
*
* All devices should respond to fully transparent by
* not drawing.
*/
return R_TRANWHITE;
for(i = 0; ColorDataBase[i].name ; i++) {
if(StrMatch(ColorDataBase[i].name, nm))
return ColorDataBase[i].code;
}
error(_("invalid color name '%s'"), nm);
return 0; /* never occurs but avoid compiler warnings */
}
/*************************************************************************
* StrMatch
*/
int StrMatch(char *string, char *pattern)
{
assert(VALID(string));
assert(VALID(pattern));
for (; ('*' != *pattern); ++pattern, ++string)
{
if (NIL == *string)
{
return (NIL == *pattern);
}
if ((toupper((int)*string) != toupper((int)*pattern))
&& ('?' != *pattern))
{
return FALSE;
}
}
/* two-line patch to prevent *too* much recursiveness: */
while ('*' == pattern[1])
pattern++;
do
{
if ( StrMatch(string, &pattern[1]) )
{
return TRUE;
}
}
while (*string++);
return FALSE;
}
/*****************************************************************************
*
* void AsnLexReadNull(aip, atp)
*
*****************************************************************************/
NLM_EXTERN void AsnLexReadNull (AsnIoPtr aip, AsnTypePtr atp)
{
AsnLexWord(aip);
if (! StrMatch("NULL", aip->word, aip->wordlen))
{
AsnIoErrorMsg(aip, 57, AsnErrGetTypeName(atp->name), aip->linenumber);
return;
}
return;
}
/*****************************************************************************
*
* AsnTypePtr AsnLexFindElement(aip, atp)
* finds an element in a list of elements
* (elements of SEQ, SET, CHOICE)
*
*****************************************************************************/
NLM_EXTERN AsnTypePtr AsnLexFindElement (AsnIoPtr aip, AsnTypePtr atp)
{
while (atp != NULL)
{
if (StrMatch(atp->name, aip->word, aip->wordlen)) /* it matches */
return atp;
else
atp = atp->next;
}
return NULL;
}
/*****************************************************************************
*
* AsnTypePtr AsnGetType(aip, amp)
* return pointer to type of last element read
*
*****************************************************************************/
NLM_EXTERN AsnTypePtr AsnGetType (AsnIoPtr aip, AsnModulePtr amp)
{
AsnTypePtr atp;
AsnPrimTypePtr aptp;
Int2 wordlen;
Int2 token;
wordlen = aip->wordlen;
token = aip->token;
if (ISA_ASNTYPE(aip->token)) /* a primitive */
{
aptp = asnprimtypes;
while (aptp->isa != token)
aptp++;
return (AsnTypePtr)aptp;
}
else if (ISA_BASETYPE(aip->token)) /* an application type */
{
aptp = asnapptypes;
while (aptp->isa != token)
aptp++;
return (AsnTypePtr)aptp;
}
if (aip->token != REF) /* not a type */
{
AsnIoErrorMsg(aip, 98, aip->word, aip->linenumber);
return NULL;
}
/**************** not a primitive - do we have it already? *******/
atp = amp->types;
while (atp != NULL)
{
if (StrMatch(atp->name, aip->word, wordlen)) /* it matches */
{
if (atp->imported == TRUE) /* reference to imported type */
atp->resolved = TRUE;
return atp;
}
else
atp = atp->next;
}
/*************** not defined - add unresolved node *************/
atp = AsnTypeNew(aip, amp);
return atp;
}
/*****************************************************************************
*
* Int2 AsnLexTMatchToken(aip)
*
*****************************************************************************/
NLM_EXTERN Int2 AsnLexTMatchToken (AsnIoPtr aip)
{
CharPtr word;
register int i;
Int2 len;
word = aip->word;
len = aip->wordlen;
for (i = 0; i < NUMASNWORD; i++)
{
if (StrMatch(asnwords[i], word, len))
return i+1;
}
return 0; /* not found */
}
int GetIndex( char* command )
{
int idx ;
int idxFound = -1 ;
for( idx = 0 ; idx < sTableSize ; idx++ )
{
if( StrMatch( sCliTable[idx].command , command ) )
{
idxFound = idx ;
break ;
}
}
return idxFound ;
}
/*****************************************************************************
*
* Int4 AsnLexReadInteger(aip, atp)
* expects an INTEGER or ENUMERATED next
* assumes none of it has already been read
* does not advance to next token
* atp points to the definition of this integer for named values
*
*****************************************************************************/
NLM_EXTERN Int4 AsnLexReadInteger (AsnIoPtr aip, AsnTypePtr atp)
{
Int2 token;
AsnValxNodePtr avnp;
AsnTypePtr atp2;
token = AsnLexWord(aip); /* read the integer */
if (token == NUMBER) /* just a number */
{
return AsnLexInteger(aip);
}
if (token != IDENT) /* not number or named value */
{
AsnIoErrorMsg(aip, 39, AsnErrGetTypeName(atp->name), aip->linenumber);
return 0;
}
/******************** read a named integer value *********/
atp2 = AsnFindBaseType(atp);
if (atp2->branch != NULL) /* named values */
{
avnp = (AsnValxNodePtr) atp2->branch;
while (avnp != NULL)
{
if (StrMatch(avnp->name, aip->word, aip->wordlen))
return avnp->intvalue;
avnp = avnp->next;
}
}
if (atp2->type->isa == ENUM_TYPE) /* enumerated MUST match named value */
{
AsnIoErrorMsg(aip, 40, AsnErrGetTypeName(atp->name), aip->linenumber);
return 0;
}
/******************* could it be a previously defined value? ***/
AsnIoErrorMsg(aip, 41, AsnErrGetTypeName(atp->name), aip->linenumber);
return 0;
}
CString CSubtitleDlDlg::LangCodeToName(LPCSTR code)
{
// accept only three-letter language codes
size_t codeLen = strlen(code);
if (codeLen != 3) {
return _T("");
}
CString name = ISO6392ToLanguage(code);
if (!name.IsEmpty()) {
// workaround for ISO6392ToLanguage function behaivior
// for unknown language code it returns the code parameter back
if (code != name) {
return name;
}
}
// support abbreviations loosely based on first letters of language name
// this list is limited to upload-enabled languages
// retrieved with:
// wget -q -O- http://www.opensubtitles.org/addons/export_languages.php | \
// awk 'NR > 1 { if ($(NF-1) == "1") print ("\"" $(NF-2) "\",")}'
static LPCSTR ltable[] = {
"Albanian", "Arabic", "Armenian", "Basque", "Bengali", "Bosnian", "Breton", "Bulgarian",
"Burmese", "Catalan", "Chinese", "Czech", "Danish", "Dutch", "English", "Esperanto",
"Estonian", "Finnish", "French", "Georgian", "German", "Galician", "Greek", "Hebrew",
"Hindi", "Croatian", "Hungarian", "Icelandic", "Indonesian", "Italian", "Japanese", "Kazakh",
"Khmer", "Korean", "Latvian", "Lithuanian", "Luxembourgish", "Macedonian", "Malayalam", "Malay",
"Mongolian", "Norwegian", "Occitan", "Persian", "Polish", "Portuguese", "Russian", "Serbian",
"Sinhalese", "Slovak", "Slovenian", "Spanish", "Swahili", "Swedish", "Syriac", "Telugu",
"Tagalog", "Thai", "Turkish", "Ukrainian", "Urdu", "Vietnamese", "Romanian", "Brazilian",
};
for (size_t i = 0; i < _countof(ltable); ++i) {
CString name2 = ltable[i];
if (StrMatch(name2, CString(code)) == codeLen) {
return name2;
}
}
return _T("");
}
static int AutomaticStartDetection()
{
char buffer[1000];
char envnum[2];
int fd = open("/dev/mtd0", O_RDONLY);
lseek(fd,0xc0000+4,SEEK_SET );
ReadOneByte(fd, envnum);
lseek(fd,0x160000+4,SEEK_SET );
ReadOneByte(fd, envnum+1);
if(envnum[0] > envnum[1])
{
lseek(fd,0xc0000,SEEK_SET );
Readn(fd, buffer, 1000);
}
else
{
lseek(fd,0x160000,SEEK_SET );
Readn(fd, buffer, 1000);
}
int offset = StrMatch(buffer,"appauto=",1000);
if(offset == 0)
{
LOG_ERROR("not find appauto!");
PrintfRed("not find appauto!");
//return -2;
}
if(*(offset+buffer) != '1')
{
PrintfRed("appauto=%c",*(offset+buffer));
//return -1;
}
else
{
PrintfGreen("AutomaticStart");
}
close(fd);
return 0;
}
/*****************************************************************************
*
* AsnTypePtr AsnTypeNew(aip, amp)
*
*****************************************************************************/
NLM_EXTERN AsnTypePtr AsnTypeNew (AsnIoPtr aip, AsnModulePtr amp)
{
AsnTypePtr atp, next;
Int2 token;
next = amp->types;
atp = amp->types;
if ((token = AsnLexTMatchToken(aip)) != 0) /* it's a reserved word */
AsnIoErrorMsg(aip, 67, asnwords[token - 1], aip->linenumber);
while (next != NULL)
{
atp = next;
next = atp->next;
if (StrMatch(atp->name, aip->word, aip->wordlen)) /* already used name */
{
if (! atp->resolved) /* needs to be resolved yet, so OK */
return atp;
else /* already defined */
{
AsnIoErrorMsg(aip, 99, AsnErrGetTypeName(atp->name), aip->linenumber);
}
}
}
next = (AsnTypePtr) MemNew(sizeof(AsnType));
next->tagclass = TAG_NONE; /* default tag class */
next->name = AsnLexSaveWord(aip);
amp->lasttype++; /* increment defined types isa */
next->isa = amp->lasttype;
if (atp == NULL) /* first one */
amp->types = next;
else
atp->next = next;
return next;
}
/*****************************************************************************
*
* AsnTypePtr AsnTypeFindType(atp, str, typeptr, count, in_it)
*
*****************************************************************************/
NLM_EXTERN AsnTypePtr AsnTypeFindType (AsnTypePtr atp, CharPtr str, AsnTypePtr PNTR typeptr, Int2 count, Boolean in_it)
{
AsnTypePtr curr, next;
CharPtr beg;
Int2 len, isa;
Boolean is_element, /* (unamed) element of setof seqof */
is_type, /* if a type, must find the original def */
got_it;
AsnTypePtr PNTR typenext;
Int2 newcount;
if (count < 0) /* off array ... error condition */
return NULL;
beg = str;
len = 0;
if (typeptr == NULL)
{
typenext = NULL;
newcount = 0;
}
else
{
newcount = count - 1;
if (newcount >= 0)
typenext = typeptr + 1;
else
typenext = NULL;
}
is_element = FALSE;
is_type = FALSE;
while ((*beg != '.') && (*beg != '\0'))
{
beg++; len++;
}
if ((*str == 'E') && (len == 1))
is_element = TRUE;
else if (IS_UPPER(*str))
is_type = TRUE;
curr = atp; /* look at this level */
while (curr != NULL)
{
got_it = FALSE;
if (is_element)
got_it = TRUE;
else if (StrMatch(curr->name, str, len)) /* found it */
{
if (! is_type)
got_it = TRUE;
else /* check that this is the real def */
{
if (! curr->imported)
got_it = TRUE;
}
}
if (got_it)
{
if (typeptr != NULL)
*typeptr = curr;
if (*beg == '\0') /* that's it */
return curr;
else /* go down the path */
{
next = AsnFindBaseType(curr);
isa = next->type->isa;
if ((next->branch != NULL) /* go further */
&& (isa != INTEGER_TYPE)
&& (isa != ENUM_TYPE))
{
next = AsnTypeFindType((AsnTypePtr) next->branch, (beg + 1), typenext, newcount, TRUE);
if (next != NULL)
return next;
}
}
}
curr = curr->next;
}
if (in_it) /* processing a path and can't find next node here */
return NULL;
curr = atp; /* start down a level */
while (curr != NULL)
{
if (curr->branch != NULL)
{
next = AsnFindBaseType(curr);
if ((next != NULL) && (next->type != NULL))
{
isa = next->type->isa;
if ((next->branch != NULL) /* go further */
&& (isa != INTEGER_TYPE)
&& (isa != ENUM_TYPE))
{
next = AsnTypeFindType((AsnTypePtr) next->branch, str, typenext, newcount, FALSE);
if (next != NULL)
{
if (typeptr != NULL)
*typeptr = curr;
return next;
}
}
}
/** else, an error has occurred, unresolved branch **/
}
curr = curr->next;
}
return NULL;
}
/*****************************************************************************
*
* AsnTypePtr AsnTxtReadId(aip, amp, atp)
* reads identifier for next value
*
*****************************************************************************/
NLM_EXTERN AsnTypePtr LIBCALL AsnTxtReadId (AsnIoPtr aip, AsnModulePtr amp, AsnTypePtr atp)
{
Int2 token, isa;
AsnTypePtr atp2, atp3, atp4;
PstackPtr currpsp, prevpsp;
Boolean is_ref;
if (! aip->type_indent) /* just starting reading */
{
if (atp == NULL) /* starting an unknown item */
{
token = AsnLexWord(aip);
if (token == EOF_TOKEN)
return NULL;
if (token != REF)
{
AsnIoErrorMsg(aip, 26, aip->linenumber);
return NULL;
}
atp = AsnLexFindType(aip, amp);
if (atp == NULL)
{
AsnIoErrorMsg(aip, 27, aip->linenumber);
return NULL;
}
token = AsnLexWord(aip);
if (token != ISDEF)
{
AsnIoErrorMsg(aip, 28, aip->linenumber);
return NULL;
}
}
else /* reading a known, possibly internal value */
{
if ((atp->name != NULL) && /* do we need to read a type ref? */
(IS_UPPER(*atp->name)))
is_ref = TRUE;
else
is_ref = FALSE;
if ((is_ref) && (aip->scan_for_start))
{
token = AsnLexScan(aip, atp->name); /* scan to start */
if (token == EOF_TOKEN)
return NULL;
if (token != ISDEF)
{
AsnIoErrorMsg(aip, 28, aip->linenumber);
return NULL;
}
}
else if ((is_ref) || (aip->bytes)) /* reading an internal value */
{
token = AsnLexWord(aip);
if (token == EOF_TOKEN)
return NULL;
if (! StrMatch(atp->name, aip->word, aip->wordlen))
{
AsnIoErrorMsg(aip, 29,AsnErrGetTypeName(atp->name), aip->linenumber);
return NULL;
}
if (token == REF) /* read of a non-internal value */
{
token = AsnLexWord(aip);
if (token != ISDEF)
{
AsnIoErrorMsg(aip, 28, aip->linenumber);
return NULL;
}
}
}
}
aip->typestack[0].type = atp; /* load first type */
aip->typestack[0].resolved = FALSE;
return atp;
}
currpsp = & aip->typestack[aip->type_indent];
prevpsp = currpsp - 1;
if (currpsp->type != NULL) /* reading in a struct */
{
token = AsnLexWord(aip);
switch (token)
{
case COMMA:
break;
case END_STRUCT:
return prevpsp->type;
default:
AsnIoErrorMsg(aip, 30, aip->linenumber);
return NULL;
}
}
/* check for SEQOF and SETOF */
atp = prevpsp->type;
atp2 = AsnFindBaseType(atp);
isa = atp2->type->isa;
if ((isa == SEQOF_TYPE) || (isa == SETOF_TYPE))
{
token = AsnLexWord(aip);
if (token == END_STRUCT) /* empty set */
return prevpsp->type;
aip->tagsaved = TRUE; /* not empty, note not read */
atp = (AsnTypePtr) atp2->branch; /* set of what type? */
currpsp->type = atp;
currpsp->resolved = FALSE;
return atp; /* no type identifier */
}
token = AsnLexWord(aip);
if (token == EOF_TOKEN)
{
AsnIoErrorMsg(aip, 17 );
return NULL;
}
if ((token == END_STRUCT) && ((isa == SEQ_TYPE) || (isa == SET_TYPE)))
return prevpsp->type; /* empty SET/SEQ */
if (token != IDENT)
{
AsnIoErrorMsg(aip, 31, aip->linenumber);
return NULL;
}
atp = AsnLexFindElement(aip, (AsnTypePtr) atp2->branch);
if (atp == NULL)
{
AsnIoErrorMsg(aip, 32, AsnErrGetTypeName(prevpsp->type->name), aip->linenumber);
return NULL;
}
if (atp2->type->isa == SEQ_TYPE) /* check sequence order */
{
atp3 = currpsp->type;
if (atp3 != NULL)
{
atp4 = (AsnTypePtr) atp2->branch;
atp3 = atp3->next;
while (atp4 != atp3)
{
if (atp == atp4)
{
AsnIoErrorMsg(aip, 33,AsnErrGetTypeName(atp->name), AsnErrGetTypeName(atp2->name), aip->linenumber);
return NULL;
}
atp4 = atp4->next;
}
}
else
atp3 = (AsnTypePtr) atp2->branch;
while ((atp3 != NULL) && (atp3 != atp))
{
if (! (atp3->optional || atp3->hasdefault))
{
AsnIoErrorMsg(aip, 34,AsnErrGetTypeName(atp3->name), AsnErrGetTypeName(atp2->name), aip->linenumber);
return NULL;
}
atp3 = atp3->next;
}
}
currpsp->type = atp;
currpsp->resolved = FALSE; /* mark first use */
return atp;
}
/*****************************************************************************
*
* Int2 AsnLexScan(aip, name)
* scans until name ::= to start reading asn.1 past garbage
*
*****************************************************************************/
static Int2 AsnLexScan (AsnIoPtr aip, CharPtr name)
{
register CharPtr pos;
Int2 token = 0;
register int linepos, len;
int done;
Boolean started = FALSE, matched_ref = FALSE;
if (aip->type_indent) /* only for start */
return ERROR_TOKEN;
if (! aip->bytes) /* no data loaded */
AsnIoGets(aip);
linepos = aip->linepos;
pos = aip->linebuf + linepos;
len = 0;
while (*pos == '\n' || *pos == '\r') /* skip empty lines */
{
pos = AsnIoGets(aip); /* get a line */
if (pos == NULL)
return EOF_TOKEN;
}
while (! started)
{
while ((* pos <= ' ') || ((*pos == '-') && (*(pos+1) == '-'))) /* skip leading white space */
{
if (*pos == '\n' || *pos == '\r')
{
pos = AsnIoGets(aip);
if (pos == NULL)
return EOF_TOKEN;
}
else if ((*pos == '-') && (*(pos+1) == '-')) /* skip comments */
{
pos += 2;
done = 0;
while (! done)
{
if ((*pos == '-') && (*(pos +1) == '-'))
{
pos += 2;
done = 1;
}
else if (*pos == '\n' || *pos == '\r')
done = 1;
else
pos++;
}
}
else
pos++;
}
aip->word = pos;
len = 0;
if (* pos == ':')
{
if ((*(pos + 1) == ':') && (*(pos + 2) == '='))
{
token = ISDEF;
pos += 2;
len = 3;
if (matched_ref)
started = TRUE;
else
{
AsnIoErrorMsg(aip, 59, *pos, aip->linenumber);
return ERROR_TOKEN;
}
}
else
matched_ref = FALSE;
}
else if (IS_UPPER(*pos)) /* a reference or keyword */
{
token = REF;
while ((IS_ALPHANUM(*pos)) || (*pos == '-'))
{
pos++; len++;
}
pos--; /* move back for increment at end */
aip->wordlen = len;
if (StrMatch(name, aip->word, (Int2)len))
matched_ref = TRUE;
else
matched_ref = FALSE;
}
else
matched_ref = FALSE;
pos++; /* move over last symbol */
}
/* found it , do normal return after ::= */
aip->linepos = pos - aip->linebuf;
aip->wordlen = len;
aip->token = token;
return token;
}
/*****************************************************************************
*
* Int2 AsnLexTWord(aip)
* reads words, punctuation, and asn keywords with 2 parts
* returns tokens defined at top
*
*****************************************************************************/
NLM_EXTERN Int2 AsnLexTWord (AsnIoPtr aip)
{
register CharPtr pos;
register int len;
Int1 state;
Int2 token, asntype, linepos;
int done;
Boolean first = FALSE, hitnewline = FALSE;
CharPtr commentptr;
if (! aip->bytes) /* no data loaded */
{
hitnewline = TRUE;
first = TRUE;
AsnIoGets(aip);
}
linepos = aip->linepos;
pos = aip->linebuf + linepos;
state = aip->state;
len = 0;
token = -1;
while (*pos == '\n' || *pos == '\r') /* skip empty lines */
{
hitnewline = TRUE;
pos = AsnIoGets(aip);
if (pos == NULL)
return EOF_TOKEN;
}
if (state == IN_STRING_STATE)
{
aip->word = pos;
if (* pos == '\"') /* end of string */
{
token = END_STRING;
pos++;
state = 0; /* reset state */
}
else
{
token = IN_STRING;
while ((* pos != '\"') && (* pos != '\n') && (* pos != '\r'))
{
pos++; len++;
}
if ((*pos != '\n') && (*pos != '\r') && (* (pos + 1) == '\"')) /* internal quote */
{
len++; /* include in previous string */
pos += 2; /* point to rest of string */
}
}
}
else if (state == IN_BITHEX_STATE)
{
aip->word = pos;
if (*pos == '\'') /* end of binhex */
{
state = 0; /* set to normal */
pos++; /* move past quote */
while (IS_WHITESP(*pos))
pos++;
if (* pos == 'H')
token = OCTETS;
else if (* pos == 'B')
token = ASNBITS;
else
{
AsnIoErrorMsg(aip, 58, aip->linenumber);
token = ERROR_TOKEN;
}
}
else
{
token = IN_BITHEX;
while ((* pos != '\'') && (* pos != '\n') && (* pos != '\r'))
{
pos++; len++;
}
}
}
else /* normal scanning */
{
done = 0;
while (! done)
{
while (* pos <= ' ') /* skip leading white space */
{
if (*pos == '\n' || *pos == '\r')
{
hitnewline = TRUE;
pos = AsnIoGets(aip);
if (pos == NULL)
return EOF_TOKEN;
}
else
pos++;
}
done = 1;
while (done && (*pos == '-') && (*(pos+1) == '-')) /* skip comments */
{
pos += 2;
if (first) /* could be revision */
{
first = FALSE;
if (StrMatch(asnwords[57], pos, 10)) /* $Revision: */
{
token = REVISION_TOKEN;
pos += 10;
while (IS_WHITESP(*pos))
pos++;
aip->word = pos;
while (IS_DIGIT(*pos)) /* eg. 1.2 */
{
len++;
pos++;
}
if (*pos == '.') /* take after . if present */
{
pos++;
len++;
while (IS_DIGIT(*pos))
{
len++;
pos++;
}
}
}
}
commentptr = pos;
done = 0;
while (! done) /* skip to end of comment */
{
if ((*pos == '-') && (*(pos +1) == '-'))
{
if (token != REVISION_TOKEN)
{
AsnLexTAddComment(commentptr, pos, aip);
if ((! hitnewline) && (aip->token != COMMENT_TOKEN))
token = COMMENT_TOKEN;
}
pos += 2;
done = 1;
}
else if (*pos == '\n' || *pos == '\r')
{
if (token != REVISION_TOKEN)
{
AsnLexTAddComment(commentptr, pos, aip);
if ((! hitnewline) && (aip->token != COMMENT_TOKEN))
token = COMMENT_TOKEN;
}
done = 1;
}
else
pos++;
}
if ((token == REVISION_TOKEN) || (token == COMMENT_TOKEN))
{
aip->linepos = pos - aip->linebuf;
aip->state = state;
aip->wordlen = len;
aip->token = token;
return token;
}
if (*pos <= ' ')
done = 0;
else
done = 1;
}
}
aip->word = pos;
if (* pos == '\"')
{
token = START_STRING;
state = IN_STRING_STATE;
}
else if (* pos == '\'')
{
token = START_BITHEX;
state = IN_BITHEX_STATE;
}
else if (* pos == ',')
token = COMMA;
else if (* pos == '{')
token = START_STRUCT;
else if (* pos == '}')
token = END_STRUCT;
else if (* pos == '[')
token = START_TAG;
else if (* pos == ']')
token = END_TAG;
else if (* pos == '(')
token = OPEN_PAREN;
else if (* pos == ')')
token = CLOSE_PAREN;
else if (* pos == ';')
token = SEMI_COLON;
else if (* pos == ':')
{
if ((*(pos + 1) == ':') && (*(pos + 2) == '='))
{
token = ISDEF;
pos += 2;
len = 3;
}
else
{
AsnIoErrorMsg(aip, 59, *pos, aip->linenumber);
token = ERROR_TOKEN;
}
}
else if (IS_UPPER(*pos)) /* a reference or keyword */
{
token = REF;
while ((IS_ALPHANUM(*pos)) || (*pos == '-'))
{
pos++; len++;
}
aip->wordlen = len;
asntype = AsnLexTMatchToken(aip); /* check types */
if (asntype) /* did it match ? */
{
if ((asntype > 27) && (asntype < 57)) /* not a primitive type */
{
token = asntype + 400; /* make a keyword type */
if (asntype == COMPS_TOKEN) /* COMPONENTS OF */
{
if ((*(pos + 1) == 'O') &&
(*(pos + 2) == 'F') &&
(IS_WHITESP(*(pos+3))))
{
pos += 3; /* move past OF */
len += 3;
}
else
AsnIoErrorMsg(aip, 89, aip->linenumber);
}
}
else if (asntype == 57) /* StringStore */
token = STRSTORE_TYPE;
else if (asntype == 59) /* BitInt */
token = BIGINT_TYPE;
else
{
switch (asntype)
{
case 3: /* BIT */
case 4: /* OCTET */
if (! StrMatch(asnwords[11], (pos+1), 6))
AsnIoErrorMsg(aip, 90, aip->linenumber);
pos += 7; /* move past STRING */
len += 7;
break;
case 11: /* SEQUENCE */
case 13: /* SET */
if ((*(pos + 1) == 'O') &&
(*(pos + 2) == 'F'))
{
asntype++; /* SET or SEQ OF */
pos += 3;
len += 3;
if (! IS_WHITESP(*pos))
AsnIoErrorMsg(aip, 91, aip->linenumber);
}
break;
case 6: /* OBJECT */
if ((! StrMatch(asnwords[55], (pos+1), 10))) /* IDENTIFIER */
AsnIoErrorMsg(aip, 92, aip->linenumber);
pos += 11;
len += 11;
break;
default:
break;
}
token = asntype + 300; /* change to point at type */
}
}
pos--; /* move back for increment at end */
len--;
}
else if (IS_LOWER(*pos)) /* an identifier or valuereference */
{
token = IDENT;
while ((IS_ALPHANUM(*pos)) || (*pos == '-'))
{
pos++; len++;
}
pos--; /* move back for increment at end */
len--;
}
else if ((IS_DIGIT(*pos)) || ((*pos == '-') && (IS_DIGIT(*(pos+1)))))
{
token = NUMBER;
if (*pos == '-')
{
pos++; len++;
}
while (IS_DIGIT(*pos))
{
pos++; len++;
}
pos--; /* move back for increment at end */
len--;
}
else
{
AsnIoErrorMsg(aip, 59, *pos, aip->linenumber);
token = ERROR_TOKEN;
}
len++; pos++; /* move over last symbol */
}
aip->linepos = pos - aip->linebuf;
aip->state = state;
aip->wordlen = len;
aip->token = token;
return token;
}
/* if no file mask is specified */
if (!strchr( path, '*' ) && !strchr( path, '?' ) )
{
return FP_AddFileName(path, count, arr);
}
FP_SplitPath( path, dpath, NULL, NULL );
flag = _findfirst( path, &fileinfo );
if ( flag != -1 )
{
do
{
if (!(fileinfo.attrib & _A_SUBDIR))
{
strcpy( name, dpath );
strcat( name, fileinfo.name );
FP_AddFileName(name, count, arr);
}
}
while ( _findnext( flag, &fileinfo ) == 0 );
_findclose( flag );
}
else
{
if ( errno != ENOENT )
{
MSG_PrintFileError( path );
return RESULT_ERR;
}
else
{
if ( strchr( path, '*' ) || strchr( path, '?' ) )
MSG_PrintError( MSG_FILE_NO_MATCH_s, path );
}
};
return RESULT_OK;
}
#else /* next part is for non WINDOWS OSes */
LOGICAL FP_ExpandMask( const char * path, size_t * count, char * ** arr )
{
DIR *dirp;
struct dirent *dp;
struct stat buf;
char dpath[TAT_MAX_FNAME_LEN];
char fmask[TAT_MAX_FNAME_LEN], ext[TAT_MAX_FNAME_LEN];
size_t fcount = 0;
if ( !path || !arr )
return RESULT_ERR;
/* if no file mask is specified */
if (!strchr( path, '*' ) && !strchr( path, '?' ) )
{
return FP_AddFileName(path, count, arr);
}
FP_SplitPath( path, dpath, fmask, ext );
strcat( fmask, ext );
/* if no path is specified, use current */
if ( dpath[0] == 0 )
{
dpath[0] = '.';
dpath[1] = '/';
dpath[2] = 0;
};
FP_NormalizePath( dpath );
dirp = opendir( dpath );
if ( dirp )
{
errno = 0;
while ( ( dp = readdir( dirp ) ) != NULL )
{
if ( StrMatch( dp->d_name, fmask ) )
{
strcpy( ext, dpath );
strcat( ext, dp->d_name );
if ( stat(ext, &buf)!=-1 && !(buf.st_mode & S_IFDIR) )
{
FP_AddFileName(ext, count, arr);
fcount++;
}
}
}
if ( errno == 0 )
{
if ( fcount == 0 )
{
if ( strchr( path, '*' ) || strchr( path, '?' ) )
MSG_PrintError( MSG_FILE_NO_MATCH_s, path );
}
closedir( dirp );
return RESULT_OK;
}
else
{
MSG_PrintFileError( path );
closedir( dirp );
}
}
else
{
MSG_PrintFileError( path );
}
return RESULT_ERR;
}
