CFSWString DealWithText(CFSWString text) { /* Proovin kogu sõnniku minema loopida */ CFSWString res; text.Trim(); text.Replace(L"\n\n", L"\n", 1); text.Replace(L"‘", L"'", 1); text.Replace(L"`", L"'", 1); text.Replace(L"´", L"'", 1); text.Replace(L"’", L"'", 1); for (INTPTR i = 0; i < text.GetLength(); i++) { CFSWString c = text.GetAt(i); CFSWString pc = res.GetAt(res.GetLength() - 1); CFSWString nc = text.GetAt(i + 1); if (c == L"'") { if (is_vowel(pc)) res += L"q"; else res += c; } else if (is_char(c)) res += c; else if (is_digit(c)) res += c; else if (is_hyphen(c) && is_char(pc) && is_char(nc)) res += sp; else if (is_symbol(c)) res += c; else if (is_colon(c) && !is_colon(pc)) res += c; else if (is_bbracket(c) && !is_bbracket(pc)) res += c; else if (is_ebracket(c) && is_ending(nc)) res += L""; else if (is_ebracket(c) && !is_ebracket(pc)) res += c; else if (is_comma(c) && !is_comma(pc)) res += c; else if (is_fchar(c)) res += replace_fchar(c); else if (is_space(c) && !is_whitespace(pc)) res += c; else if (is_break(c) && !is_break(pc)) { res += c; } //kahtlane else if (is_tab(c) && !is_whitespace(pc)) res += c; else if (is_ending(c) && !is_ending(pc) && !is_whitespace(pc)) res += c; } res.Trim(); return res; }
int erts_is_time_break(Process *p, BeamInstr *pc, Eterm *retval) { Uint i, ix; bp_time_hash_t hash; Uint size; Eterm *hp, t; bp_data_time_item_t *item = NULL; BpDataTime *bdt = (BpDataTime *) is_break(pc, (BeamInstr) BeamOp(op_i_time_breakpoint)); if (bdt) { if (retval) { /* collect all hashes to one hash */ bp_hash_init(&hash, 64); /* foreach threadspecific hash */ for (i = 0; i < bdt->n; i++) { bp_data_time_item_t *sitem; /* foreach hash bucket not NIL*/ for(ix = 0; ix < bdt->hash[i].n; ix++) { item = &(bdt->hash[i].item[ix]); if (item->pid != NIL) { sitem = bp_hash_get(&hash, item); if (sitem) { BP_TIME_ADD(sitem, item); } else { bp_hash_put(&hash, item); } } } } /* *retval should be NIL or term from previous bif in export entry */ if (hash.used > 0) { size = (5 + 2)*hash.used; hp = HAlloc(p, size); for(ix = 0; ix < hash.n; ix++) { item = &(hash.item[ix]); if (item->pid != NIL) { t = TUPLE4(hp, item->pid, make_small(item->count), make_small(item->s_time), make_small(item->us_time)); hp += 5; *retval = CONS(hp, t, *retval); hp += 2; } } } bp_hash_delete(&hash); } return !0; } return 0; }
int erts_is_count_break(BeamInstr *pc, Sint *count_ret) { BpDataCount *bdc = (BpDataCount *) is_break(pc, (BeamInstr) BeamOp(op_i_count_breakpoint)); if (bdc) { if (count_ret) { *count_ret = (Sint) erts_smp_atomic_read_nob(&bdc->acount); } return !0; } return 0; }
int erts_is_count_break(Uint *pc, Sint *count_ret) { BpDataCount *bdc = (BpDataCount *) is_break(pc, (Uint) BeamOp(op_i_count_breakpoint)); if (bdc) { if (count_ret) { ErtsSmpBPLock(bdc); *count_ret = bdc->count; ErtsSmpBPUnlock(bdc); } return !0; } return 0; }
int erts_is_mtrace_break(BeamInstr *pc, Binary **match_spec_ret, Eterm *tracer_pid_ret) { BpDataTrace *bdt = (BpDataTrace *) is_break(pc, (BeamInstr) BeamOp(op_i_mtrace_breakpoint)); if (bdt) { if (match_spec_ret) { *match_spec_ret = bdt->match_spec; } if (tracer_pid_ret) { ErtsSmpBPLock(bdt); *tracer_pid_ret = bdt->tracer_pid; ErtsSmpBPUnlock(bdt); } return !0; } return 0; }
void litehtml::el_text::parse_styles(bool is_reparse) { m_text_transform = (text_transform) value_index(get_style_property(_t("text-transform"), true, _t("none")), text_transform_strings, text_transform_none); if(m_text_transform != text_transform_none) { m_transformed_text = m_text; m_use_transformed = true; m_doc->container()->transform_text(m_transformed_text, m_text_transform); } if(is_white_space()) { m_transformed_text = _t(" "); m_use_transformed = true; } else { if(m_text == _t("\t")) { m_transformed_text = _t(" "); m_use_transformed = true; } if(m_text == _t("\n") || m_text == _t("\r")) { m_transformed_text = _t(""); m_use_transformed = true; } } font_metrics fm; uint_ptr font = m_parent->get_font(&fm); if(is_break()) { m_size.height = 0; m_size.width = 0; } else { m_size.height = fm.height; m_size.width = m_doc->container()->text_width(m_use_transformed ? m_transformed_text.c_str() : m_text.c_str(), font); } m_draw_spaces = fm.draw_spaces; }
void radc_compiler::execute() { int line = 0; while (line < statements.Size() && !is_break() && !is_error()) { int nextline = statements[line]->execute(); if (nextline == 0) { line = line + 1; } else if (nextline == -1) { line = statements.Size(); } else { line = nextline; } } }
char *get_token(char *lexeme , int mode){ char *token=(char*)calloc(strlen(lexeme)+50,sizeof(char)); //printf("Getting token\n"); if(is_long(lexeme)){ sprintf(token,"%d",LONG); } else if(is_static(lexeme)){ sprintf(token,"%d",STATIC); } else if(is_union(lexeme)){ sprintf(token,"%d",UNION); } else if(is_default(lexeme)){ sprintf(token,"%d",DEFAULT); } else if(is_break(lexeme)){ sprintf(token,"%d",BREAK); } else if(is_case(lexeme)){ sprintf(token,"%d",CASE); } else if(is_continue(lexeme)){ sprintf(token,"%d",CONTINUE); } else if(is_goto(lexeme)){ sprintf(token,"%d",GOTO); } else if(is_struct(lexeme)){ sprintf(token,"%d",STRUCT); } else if(is_const(lexeme)){ sprintf(token,"%d",CONST); } else if(is_void(lexeme)){ sprintf(token,"%d",VOID); } else if(is_switch(lexeme)){ sprintf(token,"%d",SWITCH); } else if(is_for(lexeme)){ sprintf(token,"%d",FOR); } else if(is_while(lexeme)){ sprintf(token,"%d",WHILE); } else if(is_do(lexeme)){ sprintf(token,"%d",DO); } else if(is_return(lexeme)){ sprintf(token,"%d",RETURN); } else if(is_bool(lexeme)){ sprintf(token,"%d",BOOL); } else if(is_char(lexeme)){ sprintf(token,"%d",CHAR); } else if(is_signed(lexeme)){ sprintf(token,"%d",SIGNED); } else if(is_unsigned(lexeme)){ sprintf(token,"%d",UNSIGNED); } else if(is_short(lexeme)){ sprintf(token,"%d",SHORT); } else if(is_int(lexeme)){ sprintf(token,"%d",INT); } else if(is_float(lexeme)){ sprintf(token,"%d",FLOAT); } else if(is_double(lexeme)){ sprintf(token,"%d",DOUBLE); } else if(is_l_square(lexeme)){ sprintf(token,"%d",L_SQUARE); } else if(is_r_square(lexeme)){ sprintf(token,"%d",R_SQUARE); } else if(is_l_paraen(lexeme)){ sprintf(token,"%d",L_PARAEN); } else if(is_r_paraen(lexeme)){ sprintf(token,"%d",R_PARAEN); } else if(is_l_cbrace(lexeme)){ sprintf(token,"%d",L_CBRACE); } else if(is_r_cbrace(lexeme)){ sprintf(token,"%d",R_CBRACE); } else if(is_comma(lexeme)){ sprintf(token,"%d",COMMA); } else if(is_semicol(lexeme)){ sprintf(token,"%d",SEMICOL); } else if(is_eq_eq(lexeme)){ sprintf(token,"%d",EQ_EQ); } else if(is_lesser(lexeme)){ sprintf(token,"%d",LESSER); } else if(is_less_eq(lexeme)){ sprintf(token,"%d",LESS_EQ); } else if(is_div(lexeme)){ sprintf(token,"%d",DIV); } else if(is_greater(lexeme)){ sprintf(token,"%d",GREATER); } else if(is_great_eq(lexeme)){ sprintf(token,"%d",GREAT_EQ); } else if(is_plus_eq(lexeme)){ sprintf(token,"%d",PLUS_EQ); } else if(is_minus_eq(lexeme)){ sprintf(token,"%d",MINUS_EQ); } else if(is_div_eq(lexeme)){ sprintf(token,"%d",DIV_EQ); } else if(is_mult_eq(lexeme)){ sprintf(token,"%d",MULT_EQ); } else if(is_minus_minus(lexeme)){ sprintf(token,"%d",MINUS_MINUS); } else if(is_plus_plus(lexeme)){ sprintf(token,"%d",PLUS_PLUS); } else if(is_percent(lexeme)){ sprintf(token,"%d",PERCENT); } else if(is_div(lexeme)){ sprintf(token,"%d",DIV); } else if(is_mult(lexeme)){ sprintf(token,"%d",MULT); } else if(is_minus(lexeme)){ sprintf(token,"%d",MINUS); } else if(is_plus(lexeme)){ sprintf(token,"%d",PLUS); } else if(is_int_const(lexeme)){ printf("int"); sprintf(token,"%d\t%s",INT_CONST,lexeme); } else if(is_flo_const(lexeme)){ printf("float"); sprintf(token,"%d\t%s",FLO_CONST,lexeme); } else if(is_comment_start(lexeme)){ sprintf(token,"$start"); } else if(is_comment_end(lexeme)){ sprintf(token,"$end"); } else if(is_identifier(lexeme)){ printf("Identifier"); if(mode==1) ht_set( symboltable, lexeme, "1"); sprintf(token,"%d\t%s",IDNTIFIER,lexeme); } else sprintf(token,"%d",NOTOK); return token; }
static int clear_function_break(Module *m, Uint *pc, Uint break_op) { BpData *bd; Uint **code_base = (Uint **)m->code; ASSERT(code_base); ASSERT(code_base <= (Uint **)pc); ASSERT((Uint **)pc < code_base + (m->code_length/sizeof(Uint *))); /* * Currently no trace support for native code. */ if (erts_is_native_break(pc)) { return 0; } while ( (bd = is_break(pc, break_op))) { /* Remove all breakpoints of this type. * There should be only one of each type, * but break_op may be 0 which matches any type. */ Uint op; BpData **r = (BpData **) (pc-4); ASSERT(*r); /* Find opcode for this breakpoint */ if (break_op) { op = break_op; } else { if (bd == (*r)->next) { /* First breakpoint in ring */ op = *pc; } else { op = bd->prev->orig_instr; } } if (BpSingleton(bd)) { ASSERT(*r == bd); /* Only one breakpoint to remove */ *r = NULL; *pc = bd->orig_instr; } else { BpData *bd_prev = bd->prev; BpSpliceNext(bd, bd_prev); ASSERT(BpSingleton(bd)); if (bd == *r) { /* We removed the last breakpoint in the ring */ *r = bd_prev; bd_prev->orig_instr = bd->orig_instr; } else if (bd_prev == *r) { /* We removed the first breakpoint in the ring */ *pc = bd->orig_instr; } else { bd_prev->orig_instr = bd->orig_instr; } } if (op == (Uint) BeamOp(op_i_trace_breakpoint) || op == (Uint) BeamOp(op_i_mtrace_breakpoint)) { BpDataTrace *bdt = (BpDataTrace *) bd; MatchSetUnref(bdt->match_spec); } Free(bd); ASSERT(((Uint) code_base[MI_NUM_BREAKPOINTS]) > 0); --(*(Uint*)&code_base[MI_NUM_BREAKPOINTS]); } return 1; }
static int set_function_break(Module *modp, Uint *pc, Binary *match_spec, Uint break_op, enum erts_break_op count_op, Eterm tracer_pid) { BpData *bd, **r; size_t size; Uint **code_base = (Uint **)modp->code; ASSERT(code_base); ASSERT(code_base <= (Uint **)pc); ASSERT((Uint **)pc < code_base + (modp->code_length/sizeof(Uint *))); /* * Currently no trace support for native code. */ if (erts_is_native_break(pc)) { return 0; } /* Do not allow two breakpoints of the same kind */ if ( (bd = is_break(pc, break_op))) { if (break_op == (Uint) BeamOp(op_i_trace_breakpoint) || break_op == (Uint) BeamOp(op_i_mtrace_breakpoint)) { BpDataTrace *bdt = (BpDataTrace *) bd; Binary *old_match_spec; /* Update match spec and tracer */ MatchSetRef(match_spec); ErtsSmpBPLock(bdt); old_match_spec = bdt->match_spec; bdt->match_spec = match_spec; bdt->tracer_pid = tracer_pid; ErtsSmpBPUnlock(bdt); MatchSetUnref(old_match_spec); } else { ASSERT(! match_spec); ASSERT(is_nil(tracer_pid)); if (break_op == (Uint) BeamOp(op_i_count_breakpoint)) { BpDataCount *bdc = (BpDataCount *) bd; ErtsSmpBPLock(bdc); if (count_op == erts_break_stop) { if (bdc->count >= 0) { bdc->count = -bdc->count-1; /* Stop call counter */ } } else { bdc->count = 0; /* Reset call counter */ } ErtsSmpBPUnlock(bdc); } else { ASSERT (! count_op); } } return 1; } if (break_op == (Uint) BeamOp(op_i_trace_breakpoint) || break_op == (Uint) BeamOp(op_i_mtrace_breakpoint)) { size = sizeof(BpDataTrace); } else { ASSERT(! match_spec); ASSERT(is_nil(tracer_pid)); if (break_op == (Uint) BeamOp(op_i_count_breakpoint)) { if (count_op == erts_break_reset || count_op == erts_break_stop) { /* Do not insert a new breakpoint */ return 1; } size = sizeof(BpDataCount); } else { ASSERT(! count_op); ASSERT(break_op == (Uint) BeamOp(op_i_debug_breakpoint)); size = sizeof(BpDataDebug); } } r = (BpData **) (pc-4); if (! *r) { ASSERT(*pc != (Uint) BeamOp(op_i_trace_breakpoint)); ASSERT(*pc != (Uint) BeamOp(op_i_mtrace_breakpoint)); ASSERT(*pc != (Uint) BeamOp(op_i_debug_breakpoint)); ASSERT(*pc != (Uint) BeamOp(op_i_count_breakpoint)); /* First breakpoint; create singleton ring */ bd = Alloc(size); BpInit(bd, *pc); *pc = break_op; *r = bd; } else { ASSERT(*pc == (Uint) BeamOp(op_i_trace_breakpoint) || *pc == (Uint) BeamOp(op_i_mtrace_breakpoint) || *pc == (Uint) BeamOp(op_i_debug_breakpoint) || *pc == (Uint) BeamOp(op_i_count_breakpoint)); if (*pc == (Uint) BeamOp(op_i_debug_breakpoint)) { /* Debug bp must be last, so if it is also first; * it must be singleton. */ ASSERT(BpSingleton(*r)); /* Insert new bp first in the ring, i.e second to last. */ bd = Alloc(size); BpInitAndSpliceNext(bd, *pc, *r); *pc = break_op; } else if ((*r)->prev->orig_instr == (Uint) BeamOp(op_i_debug_breakpoint)) { /* Debug bp last in the ring; insert new second to last. */ bd = Alloc(size); BpInitAndSplicePrev(bd, (*r)->prev->orig_instr, *r); (*r)->prev->orig_instr = break_op; } else { /* Just insert last in the ring */ bd = Alloc(size); BpInitAndSpliceNext(bd, (*r)->orig_instr, *r); (*r)->orig_instr = break_op; *r = bd; } } /* Init the bp type specific data */ if (break_op == (Uint) BeamOp(op_i_trace_breakpoint) || break_op == (Uint) BeamOp(op_i_mtrace_breakpoint)) { BpDataTrace *bdt = (BpDataTrace *) bd; MatchSetRef(match_spec); bdt->match_spec = match_spec; bdt->tracer_pid = tracer_pid; } else if (break_op == (Uint) BeamOp(op_i_count_breakpoint)) { BpDataCount *bdc = (BpDataCount *) bd; bdc->count = 0; } ++(*(Uint*)&code_base[MI_NUM_BREAKPOINTS]); return 1; }