//取得所有的文件版本信息，各信息间以\n分隔
CString HFileVersion::GetFullVersion()
{
CString strRet;
/*
szRet = "文件版本: " + GetFileVersion() + "\n";
szRet += "说明: " + GetFileDescription() +"\n";
szRet += "版权: " + GetLegalCopyright() +"\n";
szRet += "备注: " + GetComments() + "\n";
szRet += "产品版本: " + GetProductVersion() +"\n";
szRet += "产品名称: " + GetProductName() +"\n";
szRet += "个人用内部版本说明: " + GetPrivateBuild() +"\n";
szRet += "公司名称: " + GetCompanyName() +"\n";
szRet += "合法商标: " + GetLegalTrademarks() +"\n";
szRet += "内部名称: " + GetInternalName() +"\n";
szRet += "特殊内部版本说明: " + GetSpecialBuild() +"\n";
szRet += "源文件名: " + GetOriginalFilename() +"\n";
*/
strRet = "FileVersion: " + GetFileVersion() + "\n";
strRet += "FileDescription: " + GetFileDescription() +"\n";
strRet += "CopyRight: " + GetLegalCopyright() +"\n";
strRet += "Comments: " + GetComments() + "\n";
strRet += "ProductVersion: " + GetProductVersion() +"\n";
strRet += "ProductName: " + GetProductName() +"\n";
strRet += "PrivateBuild: " + GetPrivateBuild() +"\n";
strRet += "CompanyName: " + GetCompanyName() +"\n";
strRet += "TradeMarks: " + GetLegalTrademarks() +"\n";
strRet += "InternalName: " + GetInternalName() +"\n";
strRet += "SpecialBuild: " + GetSpecialBuild() +"\n";
strRet += "OriginalFileName: " + GetOriginalFilename() +"\n";
return strRet;
}
int
skipSpace(LexStream *L, AST **ast_ptr)
{
int c;
int commentNest;
int start_indent;
struct flexbuf cb;
AST *ast;
int startcol = 0;
int startline = 0;
flexbuf_init(&cb, INCSTR);
c = lexgetc(L);
again:
while (c == ' ' || c == '\t') {
c = lexgetc(L);
}
/* ignore completely empty lines or ones with just comments */
if (c == '\'') {
while (c == '\'') c = lexgetc(L);
while (c != '\n' && c != T_EOF) {
flexbuf_addchar(&cb, c);
c = lexgetc(L);
}
flexbuf_addchar(&cb, '\n');
flexbuf_addchar(&cb, 0);
ast = NewAST(AST_COMMENT, NULL, NULL);
ast->d.string = flexbuf_get(&cb);
comment_chain = AddToList(comment_chain, ast);
}
if (c == '{') {
struct flexbuf anno;
int annotate = 0;
int directive = 0;
int doccomment = 0;
startcol = L->colCounter;
startline = L->lineCounter;
flexbuf_init(&anno, INCSTR);
commentNest = 1;
/* check for special comments {++... } which indicate
inline C code
We also set up the preprocessor to emit {#line xx} directives when
doing #include
*/
c = lexgetc(L);
if (c == '+') {
c = lexgetc(L);
if (c == '+') {
annotate = 1;
c = lexgetc(L);
}
} else if (c == '#') {
c = lexgetc(L);
directive = 1;
} else if (c == '{') {
c = lexgetc(L);
doccomment = 1;
}
lexungetc(L, c);
for(;;) {
c = lexgetc(L);
if (c == '{' && !doccomment)
commentNest++;
else if (c == '}') {
if (doccomment) {
int peekc;
peekc = lexgetc(L);
if (peekc == '}') {
commentNest = 0;
} else {
lexungetc(L, peekc);
}
} else {
--commentNest;
}
}
if (commentNest <= 0 || c == T_EOF) {
break;
}
if (annotate || directive) {
flexbuf_addchar(&anno, c);
} else {
flexbuf_addchar(&cb, c);
}
}
if (c == T_EOF) {
if (commentNest > 0)
fprintf(stderr, "WARNING: EOF seen inside comment\n");
return c;
}
if (annotate) {
AST *ast = NewAST(AST_ANNOTATION, NULL, NULL);
flexbuf_addchar(&anno, '\0');
ast->d.string = flexbuf_get(&anno);
*ast_ptr = ast;
// if this is indented and inside a PUB or PRI,
// then treat it as inline C code
if (startcol > 1 && startline > L->block_firstline && (L->in_block == T_PUB || L->in_block == T_PRI)) {
return T_INLINECCODE;
}
return T_ANNOTATION;
} else if (directive) {
char *dir;
flexbuf_addchar(&anno, '\0');
dir = flexbuf_get(&anno);
if (!strncmp(dir, "line ", 5)) {
char *ptr = dir+5;
int lineno;
lineno = strtol(ptr, &ptr, 10);
if (lineno > 0) {
if (*ptr == ' ') ptr++;
L->fileName = strdup(ptr);
L->lineCounter = lineno;
}
}
free(dir);
} else {
flexbuf_addchar(&cb, '\0');
ast = NewAST(AST_COMMENT, NULL, NULL);
ast->d.string = flexbuf_get(&cb);
comment_chain = AddToList(comment_chain, ast);
}
c = lexgetc(L);
goto again;
}
if (L->eoln && (L->in_block == T_PUB || L->in_block == T_PRI)) {
if (c == '\n') {
c = lexgetc(L);
goto again;
}
/* if there is a pending indent, send it back */
if (L->pending_indent) {
lexungetc(L, c);
--L->pending_indent;
return T_INDENT;
}
/* on EOF send as many OUTDENTS as we need */
if (c == T_EOF) {
if (L->indentsp > 0) {
lexungetc(L, c);
--L->indentsp;
return T_OUTDENT;
}
}
/* if our indentation is <= the start value, send back an outdent */
start_indent = L->colCounter-1;
if (start_indent <= L->indent[L->indentsp] && L->indentsp > 0) {
lexungetc(L, c);
--L->indentsp;
return T_OUTDENT;
}
}
// force an end-of line at EOF
if (c == T_EOF && !L->eoln && !L->eof) {
L->eof = L->eoln = 1;
return T_EOLN;
}
if (L->eoln) {
L->eoln = 0;
L->firstNonBlank = L->colCounter-1;
}
if (c == '\n') {
L->eoln = 1;
return T_EOLN;
}
if (current && !current->sawToken) {
current->sawToken = 1;
current->topcomment = GetComments();
}
return c;
}
/* parse an identifier */
static int
parseIdentifier(LexStream *L, AST **ast_ptr, const char *prefix)
{
int c;
struct flexbuf fb;
Symbol *sym;
AST *ast = NULL;
int startColumn = L->colCounter - 1;
char *idstr;
flexbuf_init(&fb, INCSTR);
if (prefix) {
flexbuf_addmem(&fb, prefix, strlen(prefix));
if (gl_gas_dat) {
flexbuf_addchar(&fb, '.');
} else {
flexbuf_addchar(&fb, ':');
}
}
c = lexgetc(L);
while (isIdentifierChar(c)) {
//flexbuf_addchar(&fb, tolower(c));
flexbuf_addchar(&fb, c);
c = lexgetc(L);
}
// add a trailing 0, and make sure there is room for an extra
// character in case the name mangling needs it
flexbuf_addchar(&fb, '\0');
flexbuf_addchar(&fb, '\0');
idstr = flexbuf_get(&fb);
lexungetc(L, c);
/* check for reserved words */
if (InDatBlock(L)) {
sym = FindSymbol(&pasmWords, idstr);
if (sym) {
free(idstr);
if (sym->type == SYM_INSTR) {
ast = NewAST(AST_INSTR, NULL, NULL);
ast->d.ptr = sym->val;
*ast_ptr = ast;
return T_INSTR;
}
if (sym->type == SYM_INSTRMODIFIER) {
ast = NewAST(AST_INSTRMODIFIER, NULL, NULL);
ast->d.ptr = sym->val;
*ast_ptr = ast;
return T_INSTRMODIFIER;
}
fprintf(stderr, "Internal error: Unknown pasm symbol type %d\n", sym->type);
}
}
sym = FindSymbol(&reservedWords, idstr);
if (sym != NULL) {
if (sym->type == SYM_BUILTIN)
{
/* run any parse hooks */
Builtin *b = (Builtin *)sym->val;
if (b && b->parsehook) {
(*b->parsehook)(b);
}
goto is_identifier;
}
if (sym->type == SYM_CONSTANT
|| sym->type == SYM_FLOAT_CONSTANT)
{
goto is_identifier;
}
free(idstr);
if (sym->type == SYM_RESERVED) {
c = INTVAL(sym);
/* check for special handling */
switch(c) {
case T_PUB:
case T_PRI:
case T_DAT:
case T_OBJ:
case T_VAR:
case T_CON:
L->in_block = c;
L->block_firstline = L->lineCounter;
//EstablishIndent(L, 1);
break;
case T_ASM:
if (L->in_block == T_ASM) {
fprintf(stderr, "WARNING: ignoring nested asm\n");
} else {
L->save_block = L->in_block;
}
L->in_block = c;
break;
case T_ENDASM:
L->in_block = L->save_block;
break;
case T_IF:
case T_IFNOT:
case T_ELSE:
case T_ELSEIF:
case T_ELSEIFNOT:
case T_REPEAT:
case T_CASE:
EstablishIndent(L, startColumn);
break;
default:
break;
}
if (!ast)
ast = GetComments();
*ast_ptr = ast;
return c;
}
if (sym->type == SYM_HWREG) {
ast = NewAST(AST_HWREG, NULL, NULL);
ast->d.ptr = sym->val;
*ast_ptr = ast;
return T_HWREG;
}
fprintf(stderr, "Internal error: Unknown symbol type %d\n", sym->type);
}
is_identifier:
ast = NewAST(AST_IDENTIFIER, NULL, NULL);
/* make sure identifiers do not conflict with C keywords */
if (gl_normalizeIdents || Is_C_Reserved(idstr)) {
NormalizeIdentifier(idstr);
}
ast->d.string = idstr;
*ast_ptr = ast;
return T_IDENTIFIER;
}