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