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); }