bool xml_istream::parse_empty_tag(const string& s, string& open, map<string, string>& attributes)
{
bool ok = false;
open.clear();
attributes.clear();
size_t length = s.length();
size_t k = s.rfind("/>");
assert(s.find('<') == 0 && (k + 2) == length);
size_t i = 1;
if (parse_name(s, i, open) != false)
{
ok = true;
parse_ws(s, i);
while (i < k && ok != false)
{
string attribute, value;
ok = false;
if (parse_name(s, i, attribute) != false)
{
if (parse_eq(s, i) != false)
{
char ch = s[i];
if (ch == '\'' || ch == '"')
{
++i;
for (; i < k && s[i] != ch; ++i)
{
value += s[i];
}
if (s[i] == ch)
{
attributes[attribute] = value;
ok = true;
}
}
}
}
++i;
parse_ws(s, i);
}
}
return ok;
}
Subscript* parse_arg( char** p )
{
Subscript* ret = (Subscript*)malloc(sizeof(Subscript));
(*p)++;
ret->dimensions = 0;
while(1)
{
if( (ret->dimension[ret->dimensions++] = parse_expression(p))->type == TYPE_ERROR )
break;
parse_ws(p);
if( **p == ')' )
{
(*p)++;
break;
}
if( **p != ',' )
{
dispose_arg(ret);
return NULL;
}
else (*p)++;
}
return ret;
}
void load_yank(FILE *f)
{
UNDOREC *rec;
unsigned char buf[SMALL*4+80];
unsigned char bf[SMALL+1];
while(fgets((char *)buf,sizeof(buf)-1,f) && strcmp(buf,"done\n")) {
unsigned char *p = buf;
int len;
parse_ws(&p,'#');
len = parse_string(&p,bf,sizeof(bf));
if (len>0 && len<=SMALL) {
if (++nyanked == MAX_YANK) {
frrec(deque_f(UNDOREC, link, yanked.link.next));
--nyanked;
}
rec = alrec();
rec->small = (unsigned char *) joe_malloc(len);
memcpy(rec->small,bf,len);
rec->where = -1;
rec->len = len;
rec->del = 1;
enqueb(UNDOREC, link, &yanked, rec);
}
}
}
bool xml_istream::collapse_whitespace(const string& s, string& ts)
{
ts.clear();
const size_t k = s.length();
size_t i = 0;
parse_ws(s, i); /* Ignore leading whitespace. */
for (; i < k; ++i)
{
if (is_ws_char(s[i]) != false)
{
ts += ' ';
++i;
for (; i < k && is_ws_char(s[i]) != false; ++i);
--i;
}
else
{
ts += s[i];
}
}
size_t last = ts.length() - 1;
if (is_ws_char(ts[last]) != false) /* Remove tailing whitespace. */
{
ts.resize(last);
}
return ts.length() < k;
}
bool xml_istream::parse_eq(const string& s, size_t& i)
{
bool ok = false;
parse_ws(s, i);
if (s[i] == '=')
{
++i;
ok = true;
}
parse_ws(s, i);
return ok;
}
int parse_sign( char** p )
{
int ret = 0;
while(1)
{
parse_ws(p);
if( !**p ) return ret;
if( **p != '+' && **p != '-' )
return ret;
else
{
if( ret == 0 ) ret = 1;
if( **p == '-' )
ret = -ret;
}
(*p)++;
}
}
void parse_color_def(struct high_color **color_list, unsigned char *p, unsigned char *name, int line)
{
unsigned char bf[256];
if (!parse_tows(&p, bf))
{
struct high_color *color, *gcolor;
/* Find color */
color = find_color(*color_list, bf, name);
/* If it doesn't exist, create it */
if (!color)
{
color = joe_malloc(sizeof(struct high_color));
color->name = zdup(bf);
color->color = 0;
color->next = *color_list;
*color_list = color;
}
else
{
i_printf_2((char *)joe_gettext(_("%s %d: Class already defined\n")), name, line);
}
/* Find it in global list */
if (color_list != &global_colors && (gcolor = find_color(global_colors, bf, name)))
{
color->color = gcolor->color;
}
else
{
/* Parse color definition */
while (parse_ws(&p, '#'), !parse_ident(&p, bf, sizeof(bf)))
{
color->color |= meta_color(bf);
}
}
}
else
{
i_printf_2((char *)joe_gettext(_("%s %d: Missing class name\n")), name, line);
}
}
int parse_neg( char** p )
{
int ret = 0;
while(1)
{
parse_ws(p);
if( p[0][0] == 'N' &&
p[0][1] == 'O' &&
p[0][2] == 'T' &&
(p[0][3] == ' ' ||
p[0][3] == '\t') )
{
/*TODO*/
(*p)+=4;
if( ret == 0 ) ret = 1;
ret = -ret;
}
else return ret;
}
}
bool xml_istream::parse_close_tag(const string& s, string& close)
{
bool ok = false;
close.clear();
size_t length = s.length();
size_t k = s.rfind('>');
assert(s.find("</") == 0 && (k + 1) == length);
size_t i = 2;
if (parse_name(s, i, close) != false)
{
parse_ws(s, i);
if (i == k)
{
ok = true;
}
}
return ok;
}
void parse_options(struct high_syntax *syntax, struct high_cmd *cmd, FILE *f, unsigned char *p, int parsing_strings, unsigned char *name, int line)
{
unsigned char buf[1024];
unsigned char bf[256];
unsigned char bf1[256];
while (parse_ws(&p, '#'), !parse_ident(&p, bf, sizeof(bf)))
{
if (!zcmp(bf, USTR "buffer"))
{
cmd->start_buffering = 1;
}
else if (!zcmp(bf, USTR "hold"))
{
cmd->stop_buffering = 1;
}
else if (!zcmp(bf, USTR "save_c"))
{
cmd->save_c = 1;
}
else if (!zcmp(bf, USTR "save_s"))
{
cmd->save_s = 1;
}
else if (!zcmp(bf, USTR "recolor"))
{
parse_ws(&p, '#');
if (!parse_char(&p, '='))
{
parse_ws(&p, '#');
if (parse_int(&p, &cmd->recolor))
{
i_printf_2((char *)joe_gettext(_("%s %d: Missing value for option\n")), name, line);
}
}
else
{
i_printf_2((char *)joe_gettext(_("%s %d: Missing value for option\n")), name, line);
}
}
else if (!zcmp(bf, USTR "call"))
{
parse_ws(&p, '#');
if (!parse_char(&p, '='))
{
parse_ws(&p, '#');
if (!parse_char(&p, '.'))
{
zcpy(bf, syntax->name);
goto subr;
}
else if (parse_ident(&p, bf, sizeof(bf)))
{
i_printf_2((char *)joe_gettext(_("%s %d: Missing value for option\n")), name, line);
}
else
{
if (!parse_char(&p, '.'))
{
subr:
if (parse_ident(&p, bf1, sizeof(bf1)))
{
i_printf_2((char *)joe_gettext(_("%s %d: Missing subroutine name\n")), name, line);
}
cmd->call = load_syntax_subr(bf, bf1, parse_params(syntax->params, &p, name, line));
}
else
{
cmd->call = load_syntax_subr(bf, 0, parse_params(syntax->params, &p, name, line));
}
}
}
else
{
i_printf_2((char *)joe_gettext(_("%s %d: Missing value for option\n")), name, line);
}
}
else if (!zcmp(bf, USTR "return"))
{
cmd->rtn = 1;
}
else if (!zcmp(bf, USTR "reset"))
{
cmd->reset = 1;
}
else if (!parsing_strings && (!zcmp(bf, USTR "strings") || !zcmp(bf, USTR "istrings")))
{
if (bf[0] == 'i')
{
cmd->ignore = 1;
}
while (fgets((char *)buf, 1023, f))
{
++line;
p = buf;
parse_ws(&p, '#');
if (*p)
{
if (!parse_field(&p, USTR "done"))
{
break;
}
if (parse_string(&p, bf, sizeof(bf)) >= 0)
{
parse_ws(&p, '#');
if (cmd->ignore)
{
lowerize(bf);
}
if (!parse_ident(&p, bf1, sizeof(bf1)))
{
struct high_cmd *kw_cmd = mkcmd();
kw_cmd->noeat = 1;
kw_cmd->new_state = find_state(syntax, bf1);
if (!zcmp(bf, USTR "&"))
{
cmd->delim = kw_cmd;
}
else
{
if (!cmd->keywords)
{
cmd->keywords = htmk(64);
}
htadd(cmd->keywords, zdup(bf), kw_cmd);
}
parse_options(syntax, kw_cmd, f, p, 1, name, line);
}
else
{
i_printf_2((char *)joe_gettext(_("%s %d: Missing state name\n")), name, line);
}
}
else
{
i_printf_2((char *)joe_gettext(_("%s %d: Missing string\n")), name, line);
}
}
}
}
else if (!zcmp(bf, USTR "noeat"))
{
cmd->noeat = 1;
}
else if (!zcmp(bf, USTR "mark"))
{
cmd->start_mark = 1;
}
else if (!zcmp(bf, USTR "markend"))
{
cmd->stop_mark = 1;
}
else if (!zcmp(bf, USTR "recolormark"))
{
cmd->recolor_mark = 1;
}
else
{
i_printf_2((char *)joe_gettext(_("%s %d: Unknown option\n")), name, line);
}
}
}
struct high_param *parse_params(struct high_param *current_params, unsigned char **ptr, unsigned char *name, int line)
{
unsigned char *p = *ptr;
unsigned char bf[256];
struct high_param *params;
struct high_param **param_ptr;
/* Propagate currently defined parameters */
param_ptr = ¶ms;
while (current_params)
{
*param_ptr = joe_malloc(sizeof(struct high_param));
(*param_ptr)->name = zdup(current_params->name);
param_ptr = &(*param_ptr)->next;
current_params = current_params->next;
}
*param_ptr = 0;
parse_ws(&p, '#');
if (!parse_char(&p, '('))
{
for (;;)
{
parse_ws(&p, '#');
if (!parse_char(&p, ')'))
{
break;
}
else if (!parse_char(&p, '-'))
{
if (!parse_ident(&p, bf, sizeof(bf)))
{
int cmp = 0;
param_ptr = ¶ms;
/* Parameters are sorted */
while (*param_ptr && (cmp = zcmp(bf, (*param_ptr)->name)) > 0)
{
param_ptr = &(*param_ptr)->next;
}
if (*param_ptr && !cmp)
{
/* Remove this parameter */
struct high_param *param = *param_ptr;
*param_ptr = param->next;
joe_free(param);
}
}
else
{
i_printf_2((char *)joe_gettext(_("%s %d: Missing parameter name\n")), name, line);
}
}
else if (!parse_ident(&p, bf, sizeof(bf)))
{
int cmp = 0;
param_ptr = ¶ms;
/* Keep parameters sorted */
while (*param_ptr && (cmp = zcmp(bf, (*param_ptr)->name)) > 0)
{
param_ptr = &(*param_ptr)->next;
}
/* Discard duplicates */
if (!*param_ptr || cmp)
{
struct high_param *param = joe_malloc(sizeof(struct high_param));
param->name = zdup(bf);
param->next = *param_ptr;
*param_ptr = param;
}
}
else
{
i_printf_2((char *)joe_gettext(_("%s %d: Missing )\n")), name, line);
break;
}
}
}
*ptr = p;
return params;
}
static int load_po(FILE *f)
{
char buf[1024];
char msgid[1024];
char msgstr[1024];
char bf[8192];
struct charmap *po_map = locale_map;
int preload_flag = 0;
msgid[0] = 0;
msgstr[0] = 0;
while (preload_flag || fgets(buf,SIZEOF(buf)-1,f)) {
const char *p;
preload_flag = 0;
p = buf;
parse_ws(&p, '#');
if (!parse_field(&p, "msgid")) {
ptrdiff_t ofst = 0;
ptrdiff_t len;
msgid[0] = 0;
parse_ws(&p, '#');
while ((len = parse_string(&p, msgid + ofst, SIZEOF(msgid)-ofst)) >= 0) {
preload_flag = 0;
ofst += len;
parse_ws(&p, '#');
if (!*p) {
if (fgets(buf,SIZEOF(buf) - 1,f)) {
p = buf;
preload_flag = 1;
parse_ws(&p, '#');
} else {
goto bye;
}
}
}
} else if (!parse_field(&p, "msgstr")) {
ptrdiff_t ofst = 0;
ptrdiff_t len;
msgstr[0] = 0;
parse_ws(&p, '#');
while ((len = parse_string(&p, msgstr + ofst, SIZEOF(msgstr)-ofst)) >= 0) {
preload_flag = 0;
ofst += len;
parse_ws(&p, '#');
if (!*p) {
if (fgets(buf,SIZEOF(buf) - 1,f)) {
p = buf;
preload_flag = 1;
parse_ws(&p, '#');
} else {
break;
}
}
}
if (msgid[0] && msgstr[0]) {
/* Convert to locale character map */
my_iconv(bf, SIZEOF(bf), locale_map,msgstr,po_map);
/* Add to hash table */
htadd(gettext_ht, zdup(msgid), zdup(bf));
} else if (!msgid[0] && msgstr[0]) {
char *tp = zstr(msgstr, "charset=");
if (tp) {
/* Copy character set name up to next delimiter */
int x;
tp += SIZEOF("charset=") - 1;
while (*tp == ' ' || *tp == '\t') ++tp;
for (x = 0; tp[x] && tp[x] !='\n' && tp[x] != '\r' && tp[x] != ' ' &&
tp[x] != '\t' && tp[x] != ';' && tp[x] != ','; ++x)
msgid[x] = tp[x];
msgid[x] = 0;
po_map = find_charmap(msgid);
if (!po_map)
po_map = locale_map;
}
}
}
}
bye:
fclose(f);
return 0;
}
Data* parse_expression( char **p )
{
/*TODO: logic */
//return parse_aexpr(p);
Data* ret = NULL;
while(1)
{
char op;
int neg ;
Data* aexpr;
if( ret )
{/*if it is not the first expression , a logic operator expected*/
if( p[0][0] == 'A' && p[0][1] == 'N' && p[0][2] == 'D' && ( p[0][3] = ' ' || p[0][3] == '\t' ) )
{
op = 'A';
(*p)+=4;
}
else if( p[0][0] == 'O' && p[0][1] == 'R' && ( p[0][2] = ' ' || p[0][2] == '\t' ) )
{
op = 'O';
(*p)+=3;
}
else break; /*if not operator */
}
neg = parse_neg(p);
aexpr = parse_aexpr(p);
parse_ws(p);
if( aexpr->type == TYPE_ERROR )
{
dispose(ret);
return aexpr;
}
if( **p == '=' || **p == '>' || **p == '<' )
{
int flag;
Data* right/* = parse_aexpr(p)*/;
switch(**p)
{
case '=':
#define EQ 0
flag = 0; /*EQ*/
(*p)++;
break;
case '>':
if( p[0][1] == '=' )
{
(*p)+=2;
#define GE 3
flag = 3; /*GE*/
}
else
{
#define G 1
(*p)++;
flag = 1; /*G*/
}
break;
case '<':
if( p[0][1] == '=' )
{
(*p)+=2;
#define LE 4
flag = 4; /*LE*/
}
else if( p[0][1] == '>' )
{
(*p)+=2;
#define NE 5
flag = 5; /*NE*/
}
else
{
(*p)++;
#define L 2
flag = 2; /*L*/
}
}
right = parse_aexpr(p);
if( right->type == TYPE_ERROR )
{
dispose(ret);
dispose(aexpr);
return right;
}
if( right->type == TYPE_STRING )
{//String
if( aexpr->type != TYPE_STRING )
{
dispose(ret);
dispose(aexpr);
dispose(right);
return Raise(TYPE_MISMATCH);
}
else
{
Data* temp = Data_new(TYPE_INTEGER,(Storage)(short)0,1);
int result = strcmp( aexpr->storage.String , right->storage.String);
switch(flag)
{
case EQ:
temp->storage.Integer = (result == 0);
break;
case L:
temp->storage.Integer = (result < 0 );
break;
case LE:
temp->storage.Integer = (result <= 0 );
break;
case G:
temp->storage.Integer = (result > 0 );
break;
case GE:
temp->storage.Integer = (result >= 0 );
break;
case NE:
temp->storage.Integer = (result != 0 );
}
dispose(aexpr);
dispose(right);
aexpr = temp;
}
}
else
{//numeric
if( aexpr->type == TYPE_STRING )
{
dispose(right);
dispose(aexpr);
dispose(ret);
return Raise(TYPE_MISMATCH);
}
else
{
Data* temp = Data_new(TYPE_INTEGER,(Storage)(short)0,1);
int result ;
if( aexpr->type == TYPE_INTEGER )
{
aexpr->type = TYPE_REAL;
aexpr->storage.Real = aexpr->storage.Integer;
}
if( right->type == TYPE_INTEGER )
{
right->type = TYPE_REAL;
right->storage.Real = right->storage.Integer;
}
double t = aexpr->storage.Real - right->storage.Real;
if( t < 0 ) result = -1;
if( t == 0 ) result = 0;
if( t > 0 ) result = 1;
switch(flag)
{
case EQ:
temp->storage.Integer = (result == 0);
break;
case L:
temp->storage.Integer = (result < 0 );
break;
case LE:
temp->storage.Integer = (result <= 0 );
break;
case G:
temp->storage.Integer = (result > 0 );
break;
case GE:
temp->storage.Integer = (result >= 0 );
break;
case NE:
temp->storage.Integer = (result != 0 );
}
dispose(aexpr);
dispose(right);
aexpr = temp;
}
}
}
if( aexpr->type == TYPE_ERROR )
{
dispose(ret);
return aexpr;
}
if( neg )
{/*one or more NOT parsed*/
if( aexpr->type == TYPE_STRING ) /*NOT "illegal"*/
{
dispose(aexpr);
dispose(ret);
return Raise(TYPE_MISMATCH );
}
if( aexpr->type == TYPE_REAL )
{
aexpr->type = TYPE_INTEGER;
aexpr->storage.Integer = (int)(aexpr->storage.Real+.001);
}
if( aexpr->storage.Integer )
aexpr->storage.Integer = 1;
else
aexpr->storage.Integer = 0;
if( neg < 0 )
aexpr->storage.Integer = !aexpr->storage.Integer;
}
if( !ret )
{/* first expression */
ret = aexpr;
}
else
{
ret = temp_var(ret);
if( aexpr->type == TYPE_STRING )
{
dispose(aexpr);
dispose(ret);
return Raise(TYPE_MISMATCH);
}
if( aexpr->type == TYPE_REAL )
{
aexpr->type = TYPE_INTEGER;
aexpr->storage.Integer = (int)(aexpr->storage.Real+.001);
}
if( ret->type == TYPE_REAL )
{
ret->type = TYPE_INTEGER;
ret->storage.Integer = (int)(ret->storage.Real+.001);
}
if( op == 'A' )
ret->storage.Integer &= aexpr->storage.Integer;
else
ret->storage.Integer |= aexpr->storage.Integer;
dispose(aexpr);
}
}
return ret;
}
Data* parse_term( char** p )
{
Data* ret = NULL;
while(1)
{
char op;
int sign;
if( ret )
{
parse_ws(p);
op = *((*p));
if( op != '*' && op != '/' )
{
break; /*last chr should not be parsed*/
}
else
(*p)++;
}
sign=parse_sign(p);
if( sign == 0 ) sign = 1;
Data* factor = parse_factor(p);
if( factor->type == TYPE_ERROR )
{
dispose(ret);
return factor; /*throw*/
}
if( sign == -1 )
{
if( factor->type == TYPE_STRING )
{
dispose(factor);
dispose(ret);
return Raise(SYNTAX);
}
else if( factor->type == TYPE_REAL )
factor->storage.Real = -factor->storage.Real;
else
factor->storage.Integer = - factor->storage.Integer;
}
parse_ws(p);
if( **p == '^' )
{/*exponent*/
(*p)++;
Data* exponent = parse_factor(p);
factor = temp_var(factor);
if( exponent->type == TYPE_ERROR )
{
dispose(ret);
dispose(factor);
return exponent;
}
if( exponent->type == TYPE_STRING || factor->type == TYPE_STRING)
{
dispose(ret);
dispose(factor);
dispose(exponent);
return Data_new( TYPE_ERROR , (Storage)Error_new(TYPE_MISMATCH) , 1 );
}
if( factor->type == TYPE_INTEGER )
{
factor->storage.Real = factor->storage.Integer;
factor->type = TYPE_REAL;
}
if( exponent->type == TYPE_INTEGER )
{
factor->storage.Real = factor->storage.Integer;
factor->type = TYPE_REAL;
}
factor->storage.Real = exp( log(factor->storage.Real) * exponent->storage.Real);
dispose(exponent);
}
if( ret == NULL )
ret = factor;
else
{
ret = temp_var(ret);
if( ret->type == TYPE_STRING )
{
dispose(ret);
dispose(factor);
return Raise(TYPE_MISMATCH);
}
else
{
if( op == '*' )
{
if( ret->type == TYPE_REAL || factor->type == TYPE_REAL )
{
if( ret->type == TYPE_INTEGER )
{
ret->type = TYPE_REAL;
ret->storage.Real = ret->storage.Integer;
}
if( factor->type == TYPE_INTEGER )
{
factor->type = TYPE_REAL;
factor->storage.Real = factor->storage.Integer;
}
ret->storage.Real *= factor->storage.Real;
}
else
ret->storage.Integer *= factor->storage.Integer;
}
else
{
if( ret->type == TYPE_INTEGER )
{
ret->type = TYPE_REAL;
ret->storage.Real = ret->storage.Integer;
}
if( factor->type == TYPE_INTEGER )
{
factor->type = TYPE_REAL;
factor->storage.Real = factor->storage.Integer;
}
if( factor->storage.Real == 0 )
{
dispose( ret );
dispose( factor );
return Raise(DIV_BY_ZERO);
}
ret->storage.Real /= factor->storage.Real;
}
}
dispose(factor);
}
}
return ret;
}
Data* parse_factor( char** p)
{
Data* ret;
int curves = 0;
while(1)
{
parse_ws(p);
if( **p == '(' )
curves ++;
else
break;
(*p)++;
break;
}
if( curves )
{/* (((...(( parsed , expression expected */
ret = parse_expression(p);
if( ret->type == TYPE_ERROR )
{/* error occured*/
return ret;
}
while(curves--)
{
/*check ')'*/
parse_ws(p);
if( **p != ')' )
{/*syntax error , curves dose not match*/
dispose(ret);
return Raise(SYNTAX);
}
(*p)++;
}
}
else
{/* Constant , Variable , Array and Functions*/
/* INKEY$*/
parse_ws(p);
if( **p == '"' )
ret = parse_string(p);
else if(ISNUMERIC(**p) || **p == '.')
ret = parse_numeric(p);
else if( ISALPHA(**p) || **p == '_' )
{
char* id = parse_id(p);
parse_ws(p);
if(**p == '(' )
{
Subscript *arg;
Function* f;
arg = parse_arg(p);
f = get_fun(id);
if( f == NULL )
return Raise(SYNTAX);
if( arg == NULL )
return Raise(SYNTAX);
if( arg->dimension[arg->dimensions-1]->type == TYPE_ERROR )
{
ret = Data_new( TYPE_ERROR ,
(Storage)arg->dimension[--arg->dimensions]->storage,
1);
free(arg);
}
else
{
if( f->is_function )
{/*function call*/
ret = f->f.foo( arg );
}
else
{/*array*/
ret = get_arr_element( &f->f.arr , arg );
}
dispose_arg(arg);
}
}
else
{
/*variable*/
if( strcmp( id , "INKEY$") == 0 )
{
ret = Data_new( TYPE_STRING , (Storage)(char*)malloc(2) , 1 );
ret->storage.String[0] = inkey();
ret->storage.String[1] = 0;
}
else if( strcmp( id , "__LASTERR$" ) == 0 )
{
ret = Data_new( TYPE_STRING , (Storage)(char*)malloc(strlen(err_str[Last_Error.id])) , 1 );
strcpy( ret->storage.String , err_str[Last_Error.id] );
}
else if( strcmp( id, "__LASTERRNO") == 0 )
{
ret = Data_new( TYPE_REAL , (Storage)(double)Last_Error.id,1);
}
else
ret = get_var(id);
}
free(id);
}
else
{
ret =Raise(SYNTAX);
}
}
return ret;
}
struct high_state *load_dfa(struct high_syntax *syntax)
{
unsigned char name[1024];
unsigned char buf[1024];
unsigned char bf[256];
int clist[256];
unsigned char *p;
int c;
FILE *f = NULL;
struct ifstack *stack = 0;
struct high_state *state = 0; /* Current state */
struct high_state *first = 0; /* First state */
int line = 0;
int this_one = 0;
int inside_subr = 0;
/* Load it */
if ((p = (unsigned char *)exists_prefs_dir()) && strlen((const char *)p) + 2 + strlen(SYNTAX_DIR) + strlen(SYNTAX_EXT) + strlen((const char *)syntax->name) < sizeof name)
{
strcat(strcat(strcat(strcat(strcpy((char *)name, (const char *)p), SYNTAX_DIR), "/"), (const char *)syntax->name), SYNTAX_EXT);
f = fopen((char *)name, "r");
}
if (!f && (p = (unsigned char *)exists_gprefs_dir()) && strlen((const char *)p) + 2 + strlen(SYNTAX_DIR) + strlen(SYNTAX_EXT) + strlen((const char *)syntax->name) < sizeof name)
{
strcat(strcat(strcat(strcat(strcpy((char *)name, (const char *)p), SYNTAX_DIR), "/"), (const char *)syntax->name), SYNTAX_EXT);
f = fopen((char *)name, "r");
}
if (!f)
{
return 0;
}
/* Parse file */
while (fgets((char *)buf, 1023, f))
{
++line;
p = buf;
c = parse_ws(&p, '#');
if (!parse_char(&p, '.'))
{
if (!parse_ident(&p, bf, sizeof(bf)))
{
if (!zcmp(bf, USTR "ifdef"))
{
struct ifstack *st = joe_malloc(sizeof(struct ifstack));
st->next = stack;
st->else_part = 0;
st->ignore = 1;
st->skip = 1;
st->line = line;
if (!stack || !stack->ignore)
{
parse_ws(&p, '#');
if (!parse_ident(&p, bf, sizeof(bf)))
{
struct high_param *param;
for (param = syntax->params; param; param = param->next)
if (!zcmp(param->name, bf))
{
st->ignore = 0;
break;
}
st->skip = 0;
}
else
{
i_printf_2((char *)joe_gettext(_("%s %d: missing parameter for ifdef\n")), name, line);
}
}
stack = st;
}
else if (!zcmp(bf, USTR "else"))
{
if (stack && !stack->else_part)
{
stack->else_part = 1;
if (!stack->skip)
{
stack->ignore = !stack->ignore;
}
}
else
{
i_printf_2((char *)joe_gettext(_("%s %d: else with no matching if\n")), name, line);
}
}
else if (!zcmp(bf, USTR "endif"))
{
if (stack)
{
struct ifstack *st = stack;
stack = st->next;
joe_free(st);
}
else
{
i_printf_2((char *)joe_gettext(_("%s %d: endif with no matching if\n")), name, line);
}
}
else if (!zcmp(bf, USTR "subr"))
{
parse_ws(&p, '#');
if (parse_ident(&p, bf, sizeof(bf)))
{
i_printf_2((char *)joe_gettext(_("%s %d: Missing subroutine name\n")), name, line);
}
else
{
if (!stack || !stack->ignore)
{
inside_subr = 1;
this_one = 0;
if (syntax->subr && !zcmp(bf, syntax->subr))
{
this_one = 1;
}
}
}
}
else if (!zcmp(bf, USTR "end"))
{
if (!stack || !stack->ignore)
{
this_one = 0;
inside_subr = 0;
}
}
else
{
i_printf_2((char *)joe_gettext(_("%s %d: Unknown control statement\n")), name, line);
}
}
else
{
i_printf_2((char *)joe_gettext(_("%s %d: Missing control statement name\n")), name, line);
}
}
else if (stack && stack->ignore)
{
/* Ignore this line because of ifdef */
}
else if (!parse_char(&p, '='))
{
/* Parse color */
parse_color_def(&syntax->color, p, name, line);
}
else if ((syntax->subr && !this_one) || (!syntax->subr && inside_subr))
{
/* Ignore this line because it's not the code we want */
}
else if (!parse_char(&p, ':'))
{
if (!parse_ident(&p, bf, sizeof(bf)))
{
state = find_state(syntax, bf);
if (!first)
{
first = state;
}
parse_ws(&p, '#');
if (!parse_tows(&p, bf))
{
struct high_color *color;
for (color = syntax->color; color; color = color->next)
if (!zcmp(color->name, bf))
{
break;
}
if (color)
{
state->color = color->color;
}
else
{
state->color = 0;
i_printf_2((char *)joe_gettext(_("%s %d: Unknown class\n")), name, line);
}
}
else
{
i_printf_2((char *)joe_gettext(_("%s %d: Missing color for state definition\n")), name, line);
}
}
else
{
i_printf_2((char *)joe_gettext(_("%s %d: Missing state name\n")), name, line);
}
}
else if (!parse_char(&p, '-'))
{
/* No. sync lines ignored */
}
else
{
c = parse_ws(&p, '#');
if (!c)
{
}
else if (c == '"' || c == '*' || c == '&')
{
if (state)
{
struct high_cmd *cmd;
int delim = 0;
if (!parse_field(&p, USTR "*"))
{
int z;
for (z = 0; z != 256; ++z)
{
clist[z] = 1;
}
}
else if (!parse_field(&p, USTR "&"))
{
delim = 1;
}
else
{
c = parse_string(&p, bf, sizeof(bf));
if (c < 0)
{
i_printf_2((char *)joe_gettext(_("%s %d: Bad string\n")), name, line);
}
else
{
int z;
int first, second;
unsigned char *t = bf;
for (z = 0; z != 256; ++z)
{
clist[z] = 0;
}
while (!parse_range(&t, &first, &second))
{
if (first > second)
{
second = first;
}
while (first <= second)
{
clist[first++] = 1;
}
}
}
}
/* Create command */
cmd = mkcmd();
parse_ws(&p, '#');
if (!parse_ident(&p, bf, sizeof(bf)))
{
int z;
cmd->new_state = find_state(syntax, bf);
parse_options(syntax, cmd, f, p, 0, name, line);
/* Install command */
if (delim)
{
state->delim = cmd;
}
else for (z = 0; z != 256; ++z)
if (clist[z])
{
state->cmd[z] = cmd;
}
}
else
{
i_printf_2((char *)joe_gettext(_("%s %d: Missing jump\n")), name, line);
}
}
else
{
i_printf_2((char *)joe_gettext(_("%s %d: No state\n")), name, line);
}
}
else
{
i_printf_2((char *)joe_gettext(_("%s %d: Unknown character\n")), name, line);
}
}
}
while (stack)
{
struct ifstack *st = stack;
stack = st->next;
i_printf_2((char *)joe_gettext(_("%s %d: ifdef with no matching endif\n")), name, st->line);
joe_free(st);
}
fclose(f);
return first;
}
int load_po(FILE *f)
{
unsigned char buf[1024];
unsigned char msgid[1024];
unsigned char msgstr[1024];
unsigned char bf[8192];
struct charmap *po_map = locale_map;
int preload_flag = 0;
msgid[0] = 0;
msgstr[0] = 0;
while (preload_flag || fgets((char *)buf,sizeof(buf)-1,f)) {
unsigned char *p;
preload_flag = 0;
p = buf;
parse_ws(&p, '#');
if (!parse_field(&p, "msgid")) {
int ofst = 0;
int len;
msgid[0] = 0;
parse_ws(&p, '#');
while ((len = parse_string(&p, msgid + ofst, sizeof(msgid)-ofst)) >= 0) {
preload_flag = 0;
ofst += len;
parse_ws(&p, '#');
if (!*p) {
if (fgets((char *)buf,sizeof(buf) - 1,f)) {
p = buf;
preload_flag = 1;
parse_ws(&p, '#');
} else {
goto bye;
}
}
}
} else if (!parse_field(&p, "msgstr")) {
int ofst = 0;
int len;
msgstr[0] = 0;
parse_ws(&p, '#');
while ((len = parse_string(&p, msgstr + ofst, sizeof(msgstr)-ofst)) >= 0) {
preload_flag = 0;
ofst += len;
parse_ws(&p, '#');
if (!*p) {
if (fgets((char *)buf,sizeof(buf) - 1,f)) {
p = buf;
preload_flag = 1;
parse_ws(&p, '#');
} else {
break;
}
}
}
if (msgid[0] && msgstr[0]) {
/* Convert to locale character map */
my_iconv(bf,locale_map,msgstr,po_map);
/* Add to hash table */
htadd(gettext_ht, strdup(msgid), strdup(bf));
} else if (!msgid[0] && msgstr[0]) {
unsigned char *p = (unsigned char *)strstr((char *)msgstr, "charset=");
if (p) {
/* Copy character set name up to next delimiter */
int x;
p += sizeof("charset=") - 1;
while (*p == ' ' || *p == '\t') ++p;
for (x = 0; p[x] && p[x] !='\n' && p[x] != '\r' && p[x] != ' ' &&
p[x] != '\t' && p[x] != ';' && p[x] != ','; ++x)
msgid[x] = p[x];
msgid[x] = 0;
po_map = find_charmap(msgid);
if (!po_map)
po_map = locale_map;
}
}
}
}
bye:
fclose(f);
return 0;
}
Data* parse_aexpr(char** p)
{
Data* ret = NULL;
while(parse_ws(p),**p)
{
int sign ;
sign = parse_sign(p);
if( !ret || sign )
{
Data* term = parse_term(p);
if( term->type == TYPE_ERROR )
{
dispose(ret);
return term; /*Throw the error*/
}
else if( !ret ) /* First term */
{
if( sign != 0 && term->type == TYPE_STRING )
/* There are one or more negitive/positive sign before A string*/
/* e.g. : +"illegal"*/
{
dispose(term);
dispose(ret);
return Raise(SYNTAX); /*raise a syntax error*/
}
else ret = term;
if( sign < 0 )
{/*only INTEGER and REAL */
if( term->type == TYPE_INTEGER )
term->storage.Integer = -term->storage.Integer;
else
term->storage.Real = -term->storage.Real;
}
}
else if( term->type == TYPE_STRING )
{
ret = temp_var(ret);
if( sign > 0 ) /* AC + STRING */
{
if( ret->type != TYPE_STRING )
{
/* non-string + string is illegal */
dispose(term);
dispose(ret);
return Raise(TYPE_MISMATCH);
}
/* do strcat */
char* A = ret->storage.String;
char* B = term->storage.String;
int lA = strlen(A);
int lB = strlen(B);
char* temp = (char*)malloc( lA + lB + 1);
strcpy( temp , A );
strcpy( temp + lA , B );
ret->storage.String = temp;
if( A != init_value[TYPE_STRING].String )
free(A); /*dispose old string*/
dispose(term); /*dispose this term*/
}
else
{
/* AC - string is illegal */
dispose(term);
dispose(ret);
return Raise(TYPE_MISMATCH);
}
}
else if( term->type == TYPE_INTEGER )
{
ret = temp_var(ret);
/*AC + INTEGER*/
if( ret->type == TYPE_STRING )
{/*Type Mismatch*/
dispose(ret);
dispose(term);
return Raise(TYPE_MISMATCH);
}
else if( ret->type == TYPE_INTEGER )
{/*Integer + Integer*/
ret->storage.Integer += sign * term->storage.Integer;
dispose(term);
}
else if( ret->type == TYPE_REAL )
{/*Real + Integer*/
ret->storage.Real += sign * term->storage.Integer;
dispose(term);
}
}
else if( term->type == TYPE_REAL )
{
double org;
ret = temp_var(ret);
/*AC + REAL */
if( ret->type == TYPE_STRING )
{/*Type Mismatch*/
dispose(ret);
dispose(term);
return Raise(TYPE_MISMATCH);
}
if( ret->type == TYPE_REAL )
org = ret->storage.Real;
else
org = ret->storage.Integer;
ret->type = TYPE_REAL;
ret->storage.Real = org + sign * term->storage.Real;
dispose(term);
}
}
else
break;
}
if( ret == NULL )
ret=Raise(SYNTAX);
return ret;
}
