[pedevel] Re: Hex numbers patches and ASM lang

  • From: "BiPolar" <BiPolar@xxxxxxxxxxxx>
  • To: pedevel@xxxxxxxxxxxxx
  • Date: Sat, 13 Dec 2003 05:05:46 -0300 ART

Retrying because of:
> -- Binary/unsupported file stripped by Ecartis --
> -- Type: text/x-source-code
> -- File: CLang_asm.cpp
> 
> 
> -- Binary/unsupported file stripped by Ecartis --
> -- Type: text/x-assembler
> -- File: keywords.asm

If the files can't pass this time... tell me to whom should I send them (if 
there's any interest, of course).

Oscar.


-- Attached file included as plaintext by Ecartis --
-- File: CLang_asm.cpp

#include "CLanguageAddOn.h"
#include <stack>

extern "C" {
_EXPORT const char kLanguageName[] = "ASM-x86";
_EXPORT const char kLanguageExtensions[] = "as;asm;ASM;nas;s;S";
_EXPORT const char kLanguageCommentStart[] = ";";
_EXPORT const char kLanguageCommentEnd[] = "";
_EXPORT const char kLanguageKeywordFile[] = "keywords.asm";
}

enum {
        START, IDENT, COMMENT, LCOMMENT, STRING, NUMERIC, OPERATOR, SYMBOL, 
LEAVE
};

#define GETCHAR (c = (i++ < size) ? text[i - 1] : 0)

bool isOperator(char c)
{
        if (c == '@' || c == '%' || c == '+' || c == '-' || c == '*')
                return true;

        return false;
}

bool isSymbol(char c)
{
        if (c == '(' || c == ')' || c == '[' || c == ']' || c == ',' || c == 
'$')
                return true;

        return false;
}

bool isNumeric(char c)
{
        if (c >= '0' && c <= '9')
                return true;

        return false;
}

bool isHexNum(char c)
{
        if ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c 
<= 'F'))
                return true;

        return false;
}

_EXPORT void ColorLine(CLanguageProxy& proxy, int& state)
{
        const char *text = proxy.Text();
        int size = proxy.Size();
        int i = 0, s = 0, kws = 0;
        char c;
        bool leave = false;
        bool floating_point = false;
        bool hex_num = false;

        if (state == COMMENT || state == LCOMMENT)
                proxy.SetColor(0, kLCommentColor);
        else
                proxy.SetColor(0, kLTextColor);

        if (size <= 0)
                return;

        while (!leave)
        {
                GETCHAR;

                switch (state)
                {
                        case START:
                                if (isalpha(c) || c == '_')
                                {
                                        kws = proxy.Move(tolower(c), 1);
                                        state = IDENT;
                                }
                                else if (c == '/' && text[i] == '*')
                                {
                                        i++;
                                        state = COMMENT;
                                }
                                else if (c == ';' || c == '#')
                                {
                                        i++;
                                        state = LCOMMENT;
                                }
                                else if (c == '"')
                                        state = STRING;
                                else if (isNumeric(c))
                                {
                                        state = NUMERIC;
                                }
                                else if (isOperator(c))
                                {
                                        state = OPERATOR;
                                }
                                else if (isSymbol(c))
                                {
                                        state = SYMBOL;
                                }
                                else if (c == '\n' || c == 0)
                                        leave = true;

                                if (leave || (state != START && s < i))
                                {
                                        proxy.SetColor(s, kLTextColor);
                                        s = i - 1;
                                }
                        break;

                        case COMMENT:
                                if ((s == 0 || i > s + 1) && c == '*' && 
text[i] == '/')
                                {
                                        proxy.SetColor(s - 1, kLCommentColor);
                                        s = i + 1;
                                        state = START;
                                }
                                else if (c == 0 || c == '\n')
                                {
                                        proxy.SetColor(s - 1, kLCommentColor);
                                        leave = true;
                                }
                        break;

                        case LCOMMENT:
                                proxy.SetColor(s - 1, kLCommentColor);
                                leave = true;
                                if (text[size - 1] == '\n')
                                        state = START;
                        break;

                        case IDENT:
                                if (!isalnum(c) && c != '_')
                                {
                                        int kwc;

                                        if (i > s + 1 && (kwc = 
proxy.IsKeyWord(kws)) != 0)
                                        {
                                                switch (kwc)
                                                {
                                                        case 1: 
proxy.SetColor(s, kLKeyWordColor); break;
                                                        case 2: 
proxy.SetColor(s, kLUser1); break;
                                                        case 3: 
proxy.SetColor(s, kLUser2); break;
                                                        case 4: 
proxy.SetColor(s, kLUser3); break;
                                                        case 5: 
proxy.SetColor(s, kLUser4); break;
                                                }
                                        }
                                        else
                                        {
                                                proxy.SetColor(s, kLTextColor);
                                        }

                                        s = --i;
                                        state = START;
                                }
                                else if (kws)
                                        kws = proxy.Move((int)(unsigned 
char)tolower(c), kws);
                        break;

                        case STRING:
                                if (c == '"')
                                {
                                        proxy.SetColor(s, kLStringColor);
                                        s = i;
                                        state = START;
                                }
                                else if (c == '\n' || c == 0)
                                {
                                        proxy.SetColor(s, kLTextColor);
                                        state = START;
                                        s = size;
                                        leave = true;
                                }
                        break;

                        case NUMERIC:
                        {
                                proxy.SetColor(s, kLNumberColor);
                                if (isNumeric(text[i - 1]) || (hex_num && 
isHexNum(text[i - 1])))
                                        ;
                                else
                                        if (text[i - 1] == '.' && 
floating_point == false)
                                                floating_point = true;
                                        else if (text[i - 1] == 'x' && hex_num 
== false && floating_point == false)
                                                hex_num = true;
                                        else
                                        {
                                                s = i - 1;
                                                i--;
                                                hex_num = false;
                                                state = START;
                                        }
                        }
                        break;

                        case OPERATOR:
                        {
                                proxy.SetColor(s, kLOperatorColor);
                                if (isOperator(text[i - 1]))
                                        ;
                                else
                                {
                                        s = i - 1;
                                        i--;
                                        state = START;
                                }
                        }
                        break;

                        case SYMBOL:
                        {
                                proxy.SetColor(s, kLSeparatorColor);
                                if (isSymbol(text[i - 1]))
                                        ;
                                else
                                {
                                        s = i - 1;
                                        i--;
                                        state = START;
                                }
                        }
                        break;

                        default:
                                leave = true;
                        break;
                }
        }
}

-- Attached file included as plaintext by Ecartis --
-- File: keywords.asm

aaa aad aam adc add addl and andl arpl
bound bsf bsr bswap bt btc btr bts
call cbw cdq clc cld cli clts cpuid cmc cmp cmps cmpsb cmpsd cmpsw cmpxchg cwd 
cwde
daa das dec div
emms enter
f2xm1 fabs fadd faddp fbld fbstp fchs fclex fcmovb fcmovbe fcmove fcmovnb
fcmovnbe fcmovne fcmovnu fcmovu fcom fcomi fcomip fcomp fcompp fcos fdecstp fdiv
fdivp fdivr fdivrp femms ffree fiadd ficom ficomp fidiv fidivr fild fimul
fincstp finit fist fistp fisub fisubr fld fld1 fldcw fldenv fldl2e fldl2t fldlg2
fldln2 fldpi fldz fmul fmulp fnclex fninit fnop fnsave fnstcw fnstenv fnstsw
fpatan fprem1 fptan frndint frstor fsave fscale fsin fsincos fsqrt fst fstcw
fstenv fstp fstsw fsub fsubp fsubr fsubrp ftst fucom fucomi fucomip fucomp
fucompp fwait fxch fxtract fyl2xp1
hlt
idiv imul in inc incl ins insb insd insw int into invd invlpg iret iretd iretw
ja jae jb jbe jc jcxz je jecxz jg jge jl jle jmp jna jnae jnb jnbe jnc jne jng
jnge jnl jnle jno jnp jns jnz jo jp jpe jpo js jz
lahf lar lds lea leal leave les lfs lgdt lgs lidt lldt lmsw lock lods lodsb 
lodsd
lodsw loop loope loopne loopnz loopz lsl lss ltr
mov movb movd movl movq movs movsb movsd movsw movsx movw movzx movzwl mul
neg nop not or out outs outsb outsd outsw
packssdw packsswb packuswb paddb paddd paddsb paddsw paddusb paddusw paddw pand
pandn pavgusb pcmpeqb pcmpeqd pcmpeqw pcmpgtb pcmpgtd pcmpgtw pf2id pfacc pfadd
pfcmpeq pfcmpge pfcmpgt pfmax pfmin pfmul pfrcp pfrcpit1 pfrcpit2 pfrsqit1
pfrsqrt pfsub pfsubr pi2fd pmaddwd pmulhrw pmulhw pmullw pop popa popad popaw
popf popfd popfw popl por prefetch prefetchw pslld psllq psllw psrad psraw psrld
psrlq psrlw psubb psubd psubsb psubsw psubusb psubusw psubw punpckhbw punpckhdq
punpckhwd punpcklbw punpckldq punpcklwd push pusha pushad pushaw pushf pushfd
pushfw pushl pxor
rcl rcr rep repe repne repnz repz ret rol ror
sahf sal sar sbb scas scasb scasd scasw seta setae setb setbe setc sete setg
setge setl setle setna setnae setnb setnbe setnc setne setng setnge setnl setnle
setno setnp setns setnz seto setp setpo sets setz sgdt shl shld shll shr shrd 
shrl sidt
sldt smsw stc std sti stos stosb stosd stosw str sub subl
test testl
verr verw
wait wbinvd
xadd xchg xlat xlatb xor xorl
- User set 1:
bbs
code
data
text
- User set 2:
ax bx cx dx ex si di bp sp ss es ds cs ip
al ah bl bh ch cl dh dl eh el
eax ebx ebp ecx edi edx esi esp
xmm0 xmm1 xmm2 xmm3 xmm4 xmm5 xmm6 xmm7
- User set 3:
absolute align alignb at
bits
common
dword
end endstruc extern externdef
file
globl global globaldef
istruc iend
long
org
qword
short section segment segment_data segment_code size string struc
times type tword
word
- User set 4:
assign
byte
db dd define dq dt dw
else endif endmacro endrep equ error
if ifdef incbin include ifctx ifid ifidn ifidni ifnum ifstr
macro
undef
repl resb resw resq rotate
seg
wrt


Other related posts: