static int _match_aux(struct parser *p, int t)
{
if (p->t != t)
return 0;
_get_token(p, t);
return 1;
}
static int _parse_config_file(struct parser *p, struct config_tree *cft)
{
p->tb = p->te = p->fb;
p->line = 1;
_get_token(p, TOK_SECTION_E);
if (!(cft->root = _file(p)))
return_0;
return 1;
}
Error VariantConstruct::parse(const String& p_string,Variant& r_ret,String &r_err_str,int &r_err_line,Variant::ObjectConstruct* p_construct,void* p_ud) {
const CharType *str = p_string.ptr();
int idx = 0;
int len = p_string.length();
Token token;
r_err_line=0;
String aux_key;
Error err = _get_token(str,idx,len,token,r_err_line,r_err_str);
if (err)
return err;
return _parse_value(r_ret,token,str,idx,len,r_err_line,r_err_str,p_construct,p_ud);
}
Error JSON::parse(const String &p_json, Variant &r_ret, String &r_err_str, int &r_err_line) {
const CharType *str = p_json.ptr();
int idx = 0;
int len = p_json.length();
Token token;
r_err_line = 0;
String aux_key;
Error err = _get_token(str, idx, len, token, r_err_line, r_err_str);
if (err)
return err;
err = _parse_value(r_ret, token, str, idx, len, r_err_line, r_err_str);
return err;
}
Error VariantConstruct::_parse_array(Array &array,const CharType *p_str,int &index, int p_len,int &line,String &r_err_str,Variant::ObjectConstruct* p_construct,void* p_ud) {
Token token;
bool need_comma=false;
while(index<p_len) {
Error err = _get_token(p_str,index,p_len,token,line,r_err_str);
if (err!=OK)
return err;
if (token.type==TK_BRACKET_CLOSE) {
return OK;
}
if (need_comma) {
if (token.type!=TK_COMMA) {
r_err_str="Expected ','";
return ERR_PARSE_ERROR;
} else {
need_comma=false;
continue;
}
}
Variant v;
err = _parse_value(v,token,p_str,index,p_len,line,r_err_str,p_construct,p_ud);
if (err)
return err;
array.push_back(v);
need_comma=true;
}
return OK;
}
int dm_config_parse(struct dm_config_tree *cft, const char *start, const char *end)
{
/* TODO? if (start == end) return 1; */
struct parser *p;
if (!(p = dm_pool_alloc(cft->mem, sizeof(*p))))
return_0;
p->mem = cft->mem;
p->fb = start;
p->fe = end;
p->tb = p->te = p->fb;
p->line = 1;
_get_token(p, TOK_SECTION_E);
if (!(cft->root = _file(p)))
return_0;
return 1;
}
Error JSON::parse(const String& p_json,Dictionary& r_ret,String &r_err_str,int &r_err_line) {
const CharType *str = p_json.ptr();
int idx = 0;
int len = p_json.length();
Token token;
int line=0;
String aux_key;
Error err = _get_token(str,idx,len,token,line,r_err_str);
if (err)
return err;
if (token.type!=TK_CURLY_BRACKET_OPEN) {
r_err_str="Expected '{'";
return ERR_PARSE_ERROR;
}
return _parse_object(r_ret,str,idx,len,r_err_line,r_err_str);
}
VisualScriptExpression::ENode *VisualScriptExpression::_parse_expression() {
Vector<Expression> expression;
while (true) {
//keep appending stuff to expression
ENode *expr = NULL;
Token tk;
_get_token(tk);
if (error_set)
return NULL;
switch (tk.type) {
case TK_CURLY_BRACKET_OPEN: {
//a dictionary
DictionaryNode *dn = alloc_node<DictionaryNode>();
while (true) {
int cofs = str_ofs;
_get_token(tk);
if (tk.type == TK_CURLY_BRACKET_CLOSE) {
break;
}
str_ofs = cofs; //revert
//parse an expression
ENode *expr = _parse_expression();
if (!expr)
return NULL;
dn->dict.push_back(expr);
_get_token(tk);
if (tk.type != TK_COLON) {
_set_error("Expected ':'");
return NULL;
}
expr = _parse_expression();
if (!expr)
return NULL;
dn->dict.push_back(expr);
cofs = str_ofs;
_get_token(tk);
if (tk.type == TK_COMMA) {
//all good
} else if (tk.type == TK_CURLY_BRACKET_CLOSE) {
str_ofs = cofs;
} else {
_set_error("Expected ',' or '}'");
}
}
expr = dn;
} break;
case TK_BRACKET_OPEN: {
//an array
ArrayNode *an = alloc_node<ArrayNode>();
while (true) {
int cofs = str_ofs;
_get_token(tk);
if (tk.type == TK_BRACKET_CLOSE) {
break;
}
str_ofs = cofs; //revert
//parse an expression
ENode *expr = _parse_expression();
if (!expr)
return NULL;
an->array.push_back(expr);
cofs = str_ofs;
_get_token(tk);
if (tk.type == TK_COMMA) {
//all good
} else if (tk.type == TK_BRACKET_CLOSE) {
str_ofs = cofs;
} else {
_set_error("Expected ',' or ']'");
}
}
expr = an;
} break;
case TK_PARENTHESIS_OPEN: {
//a suexpression
ENode *e = _parse_expression();
if (error_set)
return NULL;
_get_token(tk);
if (tk.type != TK_PARENTHESIS_CLOSE) {
_set_error("Expected ')'");
return NULL;
}
expr = e;
} break;
case TK_IDENTIFIER: {
String what = tk.value;
int index = -1;
for (int i = 0; i < inputs.size(); i++) {
if (what == inputs[i].name) {
index = i;
break;
}
}
if (index != -1) {
InputNode *input = alloc_node<InputNode>();
input->index = index;
expr = input;
} else {
_set_error("Invalid input identifier '" + what + "'. For script variables, use self (locals are for inputs)." + what);
return NULL;
}
} break;
case TK_SELF: {
SelfNode *self = alloc_node<SelfNode>();
expr = self;
} break;
case TK_CONSTANT: {
ConstantNode *constant = alloc_node<ConstantNode>();
constant->value = tk.value;
expr = constant;
} break;
case TK_BASIC_TYPE: {
//constructor..
Variant::Type bt = Variant::Type(int(tk.value));
_get_token(tk);
if (tk.type != TK_PARENTHESIS_OPEN) {
_set_error("Expected '('");
return NULL;
}
ConstructorNode *constructor = alloc_node<ConstructorNode>();
constructor->data_type = bt;
while (true) {
int cofs = str_ofs;
_get_token(tk);
if (tk.type == TK_PARENTHESIS_CLOSE) {
break;
}
str_ofs = cofs; //revert
//parse an expression
ENode *expr = _parse_expression();
if (!expr)
return NULL;
constructor->arguments.push_back(expr);
cofs = str_ofs;
_get_token(tk);
if (tk.type == TK_COMMA) {
//all good
} else if (tk.type == TK_PARENTHESIS_CLOSE) {
str_ofs = cofs;
} else {
_set_error("Expected ',' or ')'");
}
}
expr = constructor;
} break;
case TK_BUILTIN_FUNC: {
//builtin function
_get_token(tk);
if (tk.type != TK_PARENTHESIS_OPEN) {
_set_error("Expected '('");
return NULL;
}
BuiltinFuncNode *bifunc = alloc_node<BuiltinFuncNode>();
bifunc->func = VisualScriptBuiltinFunc::BuiltinFunc(int(tk.value));
while (true) {
int cofs = str_ofs;
_get_token(tk);
if (tk.type == TK_PARENTHESIS_CLOSE) {
break;
}
str_ofs = cofs; //revert
//parse an expression
ENode *expr = _parse_expression();
if (!expr)
return NULL;
bifunc->arguments.push_back(expr);
cofs = str_ofs;
_get_token(tk);
if (tk.type == TK_COMMA) {
//all good
} else if (tk.type == TK_PARENTHESIS_CLOSE) {
str_ofs = cofs;
} else {
_set_error("Expected ',' or ')'");
}
}
int expected_args = VisualScriptBuiltinFunc::get_func_argument_count(bifunc->func);
if (bifunc->arguments.size() != expected_args) {
_set_error("Builtin func '" + VisualScriptBuiltinFunc::get_func_name(bifunc->func) + "' expects " + itos(expected_args) + " arguments.");
}
expr = bifunc;
} break;
case TK_OP_SUB: {
Expression e;
e.is_op = true;
e.op = Variant::OP_NEGATE;
expression.push_back(e);
continue;
} break;
case TK_OP_NOT: {
Expression e;
e.is_op = true;
e.op = Variant::OP_NOT;
expression.push_back(e);
continue;
} break;
default: {
_set_error("Expected expression.");
return NULL;
} break;
}
//before going to operators, must check indexing!
while (true) {
int cofs2 = str_ofs;
_get_token(tk);
if (error_set)
return NULL;
bool done = false;
switch (tk.type) {
case TK_BRACKET_OPEN: {
//value indexing
IndexNode *index = alloc_node<IndexNode>();
index->base = expr;
ENode *what = _parse_expression();
if (!what)
return NULL;
index->index = what;
_get_token(tk);
if (tk.type != TK_BRACKET_CLOSE) {
_set_error("Expected ']' at end of index.");
return NULL;
}
expr = index;
} break;
case TK_PERIOD: {
//named indexing or function call
_get_token(tk);
if (tk.type != TK_IDENTIFIER) {
_set_error("Expected identifier after '.'");
return NULL;
}
StringName identifier = tk.value;
int cofs = str_ofs;
_get_token(tk);
if (tk.type == TK_PARENTHESIS_OPEN) {
//function call
CallNode *func_call = alloc_node<CallNode>();
func_call->method = identifier;
func_call->base = expr;
while (true) {
int cofs = str_ofs;
_get_token(tk);
if (tk.type == TK_PARENTHESIS_CLOSE) {
break;
}
str_ofs = cofs; //revert
//parse an expression
ENode *expr = _parse_expression();
if (!expr)
return NULL;
func_call->arguments.push_back(expr);
cofs = str_ofs;
_get_token(tk);
if (tk.type == TK_COMMA) {
//all good
} else if (tk.type == TK_PARENTHESIS_CLOSE) {
str_ofs = cofs;
} else {
_set_error("Expected ',' or ')'");
}
}
expr = func_call;
} else {
//named indexing
str_ofs = cofs;
NamedIndexNode *index = alloc_node<NamedIndexNode>();
index->base = expr;
index->name = identifier;
expr = index;
}
} break;
default: {
str_ofs = cofs2;
done = true;
} break;
}
if (done)
break;
}
//push expression
{
Expression e;
e.is_op = false;
e.node = expr;
expression.push_back(e);
}
//ok finally look for an operator
int cofs = str_ofs;
_get_token(tk);
if (error_set)
return NULL;
Variant::Operator op = Variant::OP_MAX;
switch (tk.type) {
case TK_OP_IN: op = Variant::OP_IN; break;
case TK_OP_EQUAL: op = Variant::OP_EQUAL; break;
case TK_OP_NOT_EQUAL: op = Variant::OP_NOT_EQUAL; break;
case TK_OP_LESS: op = Variant::OP_LESS; break;
case TK_OP_LESS_EQUAL: op = Variant::OP_LESS_EQUAL; break;
case TK_OP_GREATER: op = Variant::OP_GREATER; break;
case TK_OP_GREATER_EQUAL: op = Variant::OP_GREATER_EQUAL; break;
case TK_OP_AND: op = Variant::OP_AND; break;
case TK_OP_OR: op = Variant::OP_OR; break;
case TK_OP_NOT: op = Variant::OP_NOT; break;
case TK_OP_ADD: op = Variant::OP_ADD; break;
case TK_OP_SUB: op = Variant::OP_SUBTRACT; break;
case TK_OP_MUL: op = Variant::OP_MULTIPLY; break;
case TK_OP_DIV: op = Variant::OP_DIVIDE; break;
case TK_OP_MOD: op = Variant::OP_MODULE; break;
case TK_OP_SHIFT_LEFT: op = Variant::OP_SHIFT_LEFT; break;
case TK_OP_SHIFT_RIGHT: op = Variant::OP_SHIFT_RIGHT; break;
case TK_OP_BIT_AND: op = Variant::OP_BIT_AND; break;
case TK_OP_BIT_OR: op = Variant::OP_BIT_OR; break;
case TK_OP_BIT_XOR: op = Variant::OP_BIT_XOR; break;
case TK_OP_BIT_INVERT: op = Variant::OP_BIT_NEGATE; break;
default: {};
}
if (op == Variant::OP_MAX) { //stop appending stuff
str_ofs = cofs;
break;
}
//push operator and go on
{
Expression e;
e.is_op = true;
e.op = op;
expression.push_back(e);
}
}
/* Reduce the set set of expressions and place them in an operator tree, respecting precedence */
while (expression.size() > 1) {
int next_op = -1;
int min_priority = 0xFFFFF;
bool is_unary = false;
for (int i = 0; i < expression.size(); i++) {
if (!expression[i].is_op) {
continue;
}
int priority;
bool unary = false;
switch (expression[i].op) {
case Variant::OP_BIT_NEGATE:
priority = 0;
unary = true;
break;
case Variant::OP_NEGATE:
priority = 1;
unary = true;
break;
case Variant::OP_MULTIPLY: priority = 2; break;
case Variant::OP_DIVIDE: priority = 2; break;
case Variant::OP_MODULE: priority = 2; break;
case Variant::OP_ADD: priority = 3; break;
case Variant::OP_SUBTRACT: priority = 3; break;
case Variant::OP_SHIFT_LEFT: priority = 4; break;
case Variant::OP_SHIFT_RIGHT: priority = 4; break;
case Variant::OP_BIT_AND: priority = 5; break;
case Variant::OP_BIT_XOR: priority = 6; break;
case Variant::OP_BIT_OR: priority = 7; break;
case Variant::OP_LESS: priority = 8; break;
case Variant::OP_LESS_EQUAL: priority = 8; break;
case Variant::OP_GREATER: priority = 8; break;
case Variant::OP_GREATER_EQUAL: priority = 8; break;
case Variant::OP_EQUAL: priority = 8; break;
case Variant::OP_NOT_EQUAL: priority = 8; break;
case Variant::OP_IN: priority = 10; break;
case Variant::OP_NOT:
priority = 11;
unary = true;
break;
case Variant::OP_AND: priority = 12; break;
case Variant::OP_OR: priority = 13; break;
default: {
_set_error("Parser bug, invalid operator in expression: " + itos(expression[i].op));
return NULL;
}
}
if (priority < min_priority) {
// < is used for left to right (default)
// <= is used for right to left
next_op = i;
min_priority = priority;
is_unary = unary;
}
}
if (next_op == -1) {
_set_error("Yet another parser bug....");
ERR_FAIL_COND_V(next_op == -1, NULL);
}
// OK! create operator..
if (is_unary) {
int expr_pos = next_op;
while (expression[expr_pos].is_op) {
expr_pos++;
if (expr_pos == expression.size()) {
//can happen..
_set_error("Unexpected end of expression..");
return NULL;
}
}
//consecutively do unary opeators
for (int i = expr_pos - 1; i >= next_op; i--) {
OperatorNode *op = alloc_node<OperatorNode>();
op->op = expression[i].op;
op->nodes[0] = expression[i + 1].node;
op->nodes[1] = NULL;
expression[i].is_op = false;
expression[i].node = op;
expression.remove(i + 1);
}
} else {
if (next_op < 1 || next_op >= (expression.size() - 1)) {
_set_error("Parser bug..");
ERR_FAIL_V(NULL);
}
OperatorNode *op = alloc_node<OperatorNode>();
op->op = expression[next_op].op;
if (expression[next_op - 1].is_op) {
_set_error("Parser bug..");
ERR_FAIL_V(NULL);
}
if (expression[next_op + 1].is_op) {
// this is not invalid and can really appear
// but it becomes invalid anyway because no binary op
// can be followed by a unary op in a valid combination,
// due to how precedence works, unaries will always disappear first
_set_error("Unexpected two consecutive operators.");
return NULL;
}
op->nodes[0] = expression[next_op - 1].node; //expression goes as left
op->nodes[1] = expression[next_op + 1].node; //next expression goes as right
//replace all 3 nodes by this operator and make it an expression
expression[next_op - 1].node = op;
expression.remove(next_op);
expression.remove(next_op);
}
}
return expression[0].node;
}
RES ResourceFormatPBM::load(const String &p_path,const String& p_original_path,Error *r_error) {
#define _RETURN(m_err)\
{\
if (r_error)\
*r_error=m_err;\
ERR_FAIL_V(RES());\
}
FileAccessRef f=FileAccess::open(p_path,FileAccess::READ);
uint8_t saved=0;
if (!f)
_RETURN(ERR_CANT_OPEN);
PoolVector<uint8_t> token;
if (!_get_token(f,saved,token)) {
_RETURN(ERR_PARSE_ERROR);
}
if (token.size()!=2) {
_RETURN(ERR_FILE_CORRUPT);
}
if (token[0]!='P') {
_RETURN(ERR_FILE_CORRUPT);
}
if (token[1]!='1' && token[1]!='4') {
_RETURN(ERR_FILE_CORRUPT);
}
bool bits = token[1]=='4';
if (!_get_token(f,saved,token)) {
_RETURN(ERR_PARSE_ERROR);
}
int width = _get_number_from_token(token);
if (width<=0) {
_RETURN(ERR_FILE_CORRUPT);
}
if (!_get_token(f,saved,token)) {
_RETURN(ERR_PARSE_ERROR);
}
int height = _get_number_from_token(token);
if (height<=0) {
_RETURN(ERR_FILE_CORRUPT);
}
Ref<BitMap> bm;
bm.instance();
bm->create(Size2i(width,height));
if (!bits) {
int required_bytes = width*height;
if (!_get_token(f,saved,token,false,true)) {
_RETURN(ERR_PARSE_ERROR);
}
if (token.size()<required_bytes) {
_RETURN(ERR_FILE_CORRUPT);
}
PoolVector<uint8_t>::Read r=token.read();
for(int i=0;i<height;i++) {
for(int j=0;j<width;j++) {
char num = r[i*width+j];
bm->set_bit(Point2i(j,i),num=='0');
}
}
} else {
//a single, entire token of bits!
if (!_get_token(f,saved,token,true)) {
_RETURN(ERR_PARSE_ERROR);
}
int required_bytes = Math::ceil((width*height)/8.0);
if (token.size()<required_bytes) {
_RETURN(ERR_FILE_CORRUPT);
}
PoolVector<uint8_t>::Read r=token.read();
int bitwidth = width;
if (bitwidth % 8)
bitwidth+=8-(bitwidth%8);
for(int i=0;i<height;i++) {
for(int j=0;j<width;j++) {
int ofs = bitwidth*i+j;
uint8_t byte = r[ofs/8];
bool bit = (byte>>(7-(ofs%8)))&1;
bm->set_bit(Point2i(j,i),!bit);
}
}
}
return bm;
}
Error VariantConstruct::_parse_dict(Dictionary &dict,const CharType *p_str,int &index, int p_len,int &line,String &r_err_str,Variant::ObjectConstruct* p_construct,void* p_ud) {
bool at_key=true;
Variant key;
Token token;
bool need_comma=false;
while(index<p_len) {
if (at_key) {
Error err = _get_token(p_str,index,p_len,token,line,r_err_str);
if (err!=OK)
return err;
if (token.type==TK_CURLY_BRACKET_CLOSE) {
return OK;
}
if (need_comma) {
if (token.type!=TK_COMMA) {
r_err_str="Expected '}' or ','";
return ERR_PARSE_ERROR;
} else {
need_comma=false;
continue;
}
}
err = _parse_value(key,token,p_str,index,p_len,line,r_err_str,p_construct,p_ud);
if (err!=OK)
return err;
err = _get_token(p_str,index,p_len,token,line,r_err_str);
if (err!=OK)
return err;
if (token.type!=TK_COLON) {
r_err_str="Expected ':'";
return ERR_PARSE_ERROR;
}
at_key=false;
} else {
Error err = _get_token(p_str,index,p_len,token,line,r_err_str);
if (err!=OK)
return err;
Variant v;
err = _parse_value(v,token,p_str,index,p_len,line,r_err_str,p_construct,p_ud);
if (err)
return err;
dict[key]=v;
need_comma=true;
at_key=true;
}
}
return OK;
}
main(int argc, char **argv[])
{
/* <worker id="234567"> */
_distributor = _open_space("distributor", 0, "234567");
_constructor = _open_space("constructor", 0, "234567");
while (1)
{
/* <token action="GET" idxset="(i)(j)"/> */
sprintf(_tp_name, "token#%s", "234567");
_tp_size = 0;
_tp_size = _get_token(_distributor, _tp_name, (char *)_tp_token, _tp_size);
if (_tp_size < 0) exit(-1);
if (_tp_token[0] == '!') break;
sscanf(_tp_token, "%d@(i:%d~%d,%d)(j:%d~%d,%d)", &_tokens, &_i_start, &_i_stop, &_i_step, &_j_start, &_j_stop, &_j_step);
if (_tokens >= _batch_flag)
{
/* <read var="A" type="double[DIM+2 ][DIM+2 ]"/> */
sprintf(_tp_name, "double(%d)(%d):A#%s", (DIM+2), (DIM+2), "234567");
_tp_size = ((DIM+2) * (DIM+2)) * sizeof(double);
_tp_A_234567 = (double *)malloc(_tp_size);
_tp_size = _read_data(_distributor, _tp_name, (char *)_tp_A_234567, _tp_size);
if (_tp_size < 0) exit(-1);
for (_x0_234567 = 0; _x0_234567 < (DIM+2); _x0_234567 +=1) {
for (_x1_234567 = 0; _x1_234567 < (DIM+2); _x1_234567 +=1) {
A[_x0_234567][_x1_234567] = _tp_A_234567[_x0_234567 * (DIM+2) + _x1_234567];
}
}
free(_tp_A_234567);
}
_batch_flag = _tokens;
/* <read var="A" type="double[DIM+2(i:$L-1)][DIM+2(j) ]" opt="XCHG"/> */
sprintf(_tp_name, "double(%d)(%d):A#%s[%d~%d,%d][%d~%d,%d]@%d", (DIM+2), (DIM+2), "234567", (_i_start-1), _i_start, _i_step, _j_start, _j_stop, _j_step, sizeof(double));
_tp_size = (((_i_start - (_i_start-1) - 1) / _i_step + 1) * ((_j_stop - _j_start - 1) / _j_step + 1)) * sizeof(double);
_tp_A_234567 = (double *)malloc(_tp_size);
_tp_size = _read_data(_constructor, _tp_name, (char *)_tp_A_234567, _tp_size);
if (_tp_size < 0) exit(-1);
for (_x0_234567 = (_i_start-1), _y0_234567 =0; _x0_234567 < _i_start; _x0_234567 +=_i_step, _y0_234567 ++) {
for (_x1_234567 = _j_start, _y1_234567 =0; _x1_234567 < _j_stop; _x1_234567 +=_j_step, _y1_234567 ++) {
A[_x0_234567][_x1_234567] = _tp_A_234567[_y0_234567 * ((_j_stop - _j_start - 1) / _j_step + 1) + _y1_234567];
}
}
free(_tp_A_234567);
/* <read var="A" type="double[DIM+2(i) ][DIM+2(j:$L-1)]" opt="XCHG"/> */
sprintf(_tp_name, "double(%d)(%d):A#%s[%d~%d,%d][%d~%d,%d]@%d", (DIM+2), (DIM+2), "234567", _i_start, _i_stop, _i_step, (_j_start-1), _j_start, _j_step, sizeof(double));
_tp_size = (((_i_stop - _i_start - 1) / _i_step + 1) * ((_j_start - (_j_start-1) - 1) / _j_step + 1)) * sizeof(double);
_tp_A_234567 = (double *)malloc(_tp_size);
_tp_size = _read_data(_constructor, _tp_name, (char *)_tp_A_234567, _tp_size);
if (_tp_size < 0) exit(-1);
for (_x0_234567 = _i_start, _y0_234567 =0; _x0_234567 < _i_stop; _x0_234567 +=_i_step, _y0_234567 ++) {
for (_x1_234567 = (_j_start-1), _y1_234567 =0; _x1_234567 < _j_start; _x1_234567 +=_j_step, _y1_234567 ++) {
A[_x0_234567][_x1_234567] = _tp_A_234567[_y0_234567 * ((_j_start - (_j_start-1) - 1) / _j_step + 1) + _y1_234567];
}
}
free(_tp_A_234567);
/*
* Refine the values in A, these two loops consume most of
* the computational time.
*/
resid = 0.0;
/* <target index ="i" order ="1" limits="(1,rdim+1,1)" chunk ="GRAIN"> */
for (i = _i_start; i < _i_stop; i +=_i_step)
/* </target> */
{
/* <target index ="j" order ="1" limits="(1,DIM+1,1)" chunk ="GRAIN"> */
for (j = _j_start; j < _j_stop; j +=_j_step)
/* </target> */
{
Atmp = A[i][j];
A[i][j] = 0.25 * (A[i+1][j] + A[i-1][j] +
A[i][j+1] + A[i][j-1]);
residtmp = (Atmp!=0.0? fabs(fabs(A[i][j]-Atmp)/Atmp) : (1.0+EPS));
if (residtmp > resid)
resid = residtmp;
}
}
/* <send var="resid" type="double" opt="_MAX"/> */
sprintf(_tp_name, "double:resid#%s?MAX@%d", "234567", _tokens);
_tp_size = sizeof(double);
_tp_resid_234567 = &resid;
_status = _send_data(_constructor, _tp_name, (char *)_tp_resid_234567, _tp_size);
if (_status < 0) exit(-1);
/* <send var="A" type="double[DIM+2(i) ][DIM+2(j) ]"/> */
sprintf(_tp_name, "double(%d)(%d):A#%s[%d~%d,%d][%d~%d,%d]@%d", (DIM+2), (DIM+2), "234567", _i_start, _i_stop, _i_step, _j_start, _j_stop, _j_step, sizeof(double));
_tp_size = (((_i_stop - _i_start - 1) / _i_step + 1) * ((_j_stop - _j_start - 1) / _j_step + 1)) * sizeof(double);
_tp_A_234567 = (double *)malloc(_tp_size);
for (_x0_234567 = _i_start, _y0_234567 =0; _x0_234567 < _i_stop; _x0_234567 +=_i_step, _y0_234567 ++) {
for (_x1_234567 = _j_start, _y1_234567 =0; _x1_234567 < _j_stop; _x1_234567 +=_j_step, _y1_234567 ++) {
_tp_A_234567[_y0_234567 * ((_j_stop - _j_start - 1) / _j_step + 1) + _y1_234567] = A[_x0_234567][_x1_234567];
}
}
_status = _send_data(_constructor, _tp_name, (char *)_tp_A_234567, _tp_size);
if (_status < 0) exit(-1);
free(_tp_A_234567);
}
_close_space(_constructor, "234567", 0);
_close_space(_distributor, "234567", 0);
/* </worker> */
exit(0);
}
main(int argc, char **argv[])
{
/* <worker id="123"> */
_distributor = _open_space("distributor", 0, "123");
_constructor = _open_space("constructor", 0, "123");
/* <read var="v" type="double" opt="ONCE"/> */
sprintf(_tp_name, "double:v#%s", "123");
_tp_size = sizeof(double);
_tp_v_123 = &v;
_tp_size = _read_data(_distributor, _tp_name, (char *)_tp_v_123, _tp_size);
if (_tp_size < 0) exit(-1);
while (1)
{
/* <token action="GET" idxset="(i)(j)"/> */
sprintf(_tp_name, "token#%s", "123");
_tp_size = 0;
_tp_size = _get_token(_distributor, _tp_name, (char *)_tp_token, _tp_size);
if (_tp_size < 0) exit(-1);
if (_tp_token[0] == '!') break;
sscanf(_tp_token, "%d@(i:%d~%d,%d)(j:%d~%d,%d)", &_tokens, &_i_start, &_i_stop, &_i_step, &_j_start, &_j_stop, &_j_step);
/* <read var="A" type="double[N(i)][N(j)]"/> */
sprintf(_tp_name, "double(%d)(%d):A#%s[%d~%d,%d][%d~%d,%d]@%d", (N), (N), "123", _i_start, _i_stop, 1, _j_start, _j_stop, 1, sizeof(double));
_tp_size = (((_i_stop - _i_start - 1) / 1 + 1) * ((_j_stop - _j_start - 1) / 1 + 1)) * sizeof(double);
_tp_A_123 = (double *)malloc(_tp_size);
_tp_size = _read_data(_distributor, _tp_name, (char *)_tp_A_123, _tp_size);
if (_tp_size < 0) exit(-1);
for (_x0_123 = _i_start, _y0_123 =0; _x0_123 < _i_stop; _x0_123 +=1, _y0_123 ++) {
for (_x1_123 = _j_start, _y1_123 =0; _x1_123 < _j_stop; _x1_123 +=1, _y1_123 ++) {
A[_x0_123][_x1_123] = _tp_A_123[_y0_123 * ((_j_stop - _j_start - 1) / 1 + 1) + _y1_123];
}
}
free(_tp_A_123);
/* <target index ="i" order ="1" limits="(0,N,1)" chunk ="G"> */
for (i = _i_start; i < _i_stop; i +=_i_step)
/* </target> */
{
/* <target index ="j" order ="2" limits="(0,N,1)" chunk ="G"> */
for (j = _j_start; j < _j_stop; j +=_j_step)
/* </target> */
{
A[i, j] = v;
}
}
/* <send var="A" type="double[N(i)][N(j)]"/> */
sprintf(_tp_name, "double(%d)(%d):A#%s[%d~%d,%d][%d~%d,%d]@%d", (N), (N), "123", _i_start, _i_stop, 1, _j_start, _j_stop, 1, sizeof(double));
_tp_size = (((_i_stop - _i_start - 1) / 1 + 1) * ((_j_stop - _j_start - 1) / 1 + 1)) * sizeof(double);
_tp_A_123 = (double *)malloc(_tp_size);
for (_x0_123 = _i_start, _y0_123 =0; _x0_123 < _i_stop; _x0_123 +=1, _y0_123 ++) {
for (_x1_123 = _j_start, _y1_123 =0; _x1_123 < _j_stop; _x1_123 +=1, _y1_123 ++) {
_tp_A_123[_y0_123 * ((_j_stop - _j_start - 1) / 1 + 1) + _y1_123] = A[_x0_123][_x1_123];
}
}
_status = _send_data(_constructor, _tp_name, (char *)_tp_A_123, _tp_size);
if (_status < 0) exit(-1);
free(_tp_A_123);
}
_close_space(_constructor, "123", 0);
_close_space(_distributor, "123", 0);
/* </worker> */
exit(0);
}
