Exemplo n.º 1
0
static void ProcLibrary( void )
/*****************************/
{
    bool gotprivate;

    gotprivate = ProcessKeyword( LibraryTypes );
    FmtInfo = DLL_INITGLOBAL;
    if( !MakeToken( SEP_NO, true ) ) {
        return;
    }
    if( !IsInitType() ) {
        if( CmdFile->len > 8 ) {
            Warning( "module name too large", OPTION_SLOT );
        } else if( GotModName ) {
            Warning( "module name multiply defined" , OPTION_SLOT );
        } else {
            AddStringOption( "modname", CmdFile->token, CmdFile->len );
            GotModName = true;
        }
        if( !MakeToken( SEP_NO, true ) ) {
            return;
        }
    }
    if( !IsInitType() ) {
        DirectiveError();
    }
    if( !gotprivate ) {
        ProcessKeyword( LibraryTypes );
    }
}
Exemplo n.º 2
0
static void ProcName( void )
/**************************/
{
    int index;

    if( !MakeToken( SEP_NO, true ) ) {
        return;
    }
    if( !ProcessKeyList( ApplicationTypes, CmdFile->token, CmdFile->len ) ) {
        if( GotModName ) {
            Warning( "module name multiply defined", OPTION_SLOT );
        } else {
            AddStringOption( "modname", CmdFile->token, CmdFile->len );
            GotModName = true;
        }
    }
    for( index = 0; index < 2; index++ ) {
        if( !MakeToken( SEP_NO, true ) ) {
            return;
        }
        if( !ProcessKeyList( ApplicationTypes, CmdFile->token, CmdFile->len ) ) {
            DirectiveError();
        }
    }
}
Exemplo n.º 3
0
static void ProcAppLoader( void )
/*******************************/
{
    NotSupported( "apploader" );
    if( !MakeToken( SEP_QUOTE, true ) ) {
        MakeToken( SEP_NO, true );
    }
}
Exemplo n.º 4
0
static void ProcInclude ( void )
/******************************/
{
    if( MakeToken( SEP_QUOTE, true ) || MakeToken( SEP_NO, true ) ) {
        StartNewFile( ToString() );
        ParseDefFile();
    } else {
        Warning( "invalid include statement", OPTION_SLOT );
    }
}
Exemplo n.º 5
0
static void ProcOvl( void )
/*************************/
{
    MakeToken( SEP_COLON, false );
    Warning( "ovl option on segment directive not supported by wlink", OPTION_SLOT );
    GotOvl = true;
}
Exemplo n.º 6
0
static void ProcFunctions( void )
/*******************************/
{
    Warning( "Functions style overlay management not directly translatable to watcom", OPTION_SLOT );
    MakeToken( SEP_COLON, false );       // skip number.
    MultiLine = SkipFunction;
}
Exemplo n.º 7
0
static void ProcClass( void )
/***************************/
{
    if( !MakeToken( SEP_QUOTE, true ) ) {
        Warning( "class argument invalid", OPTION_SLOT );
    }
}
Exemplo n.º 8
0
	Error Lexer(const wchar_t*& Input , vector<LexerToken>& Tokens , bool StopAtLineBreak)
	{
		Error aError;
		aError.Position=0;
		Tokens.clear();
		while(true)
		{
			int Count=0;
			LexerChars(Input,lSpace);
			if(Count=LexerName(Input))
			{
				Tokens.push_back(MakeToken(Input,ltName,Count,0,0));
			}
			else if(Count=LexerString(Input))
			{
				Tokens.push_back(MakeToken(Input,ltString,Count,1,1));
			}
			else if(Count=LexerReal(Input))
			{
				Tokens.push_back(MakeToken(Input,ltReal,Count,0,0));
			}
			else if(Count=LexerInt(Input))
			{
				Tokens.push_back(MakeToken(Input,ltInt,Count,0,0));
			}
			else if(Count=LexerChar(Input,L':'))
			{
				Tokens.push_back(MakeToken(Input,ltColon,Count,0,0));
			}
			else if(Count=LexerChars(Input,lSpaceCrLf))
			{
				if(StopAtLineBreak)break;
			}
			else if(*Input==L'\0')
			{
				break;
			}
			else
			{
				aError.Position=Input;
				aError.Message=wstring(L"遇到不可识别字符:")+(*Input)+L"。";
				break;
			}
		}
		return aError;
	}
Exemplo n.º 9
0
static void ProcOld( void )
/*************************/
{
    if( !MakeToken( SEP_QUOTE, TRUE ) ) {
        Warning( "argument for old not valid", OPTION_SLOT );
    } else {
        AddStringOption( "old", CmdFile->token, CmdFile->len );
    }
}
Exemplo n.º 10
0
static void ProcStub( void )
/**************************/
{
    if( !MakeToken( SEP_QUOTE, true ) ) {
        Warning( "argument for stub not valid", OPTION_SLOT );
    } else {
        AddStringOption( "stub", CmdFile->token, CmdFile->len );
    }
}
Exemplo n.º 11
0
static void GetSegments( void )
/*****************************/
{
    char    *segname;
    size_t  seglen;
    char    buffer[ CODE_BUFFER_LEN ];
    char    *result;
    char    *currloc;
    size_t  len;

    GotOvl = false;
    if( MakeToken( SEP_QUOTE, true ) || MakeToken( SEP_NO, true ) ) {
        DUPBUF_STACK( segname, CmdFile->token, CmdFile->len );    // store it temporarily
        seglen = CmdFile->len;
    } else {
        Warning( "segment argument not recognized", OPTION_SLOT );
        return;
    }
    if( ProcessKeyword( SegOptions ) ) {        // process the options
        ProcessKeyword( SegOptions );
    }
    OptionBuffer = buffer;
    BufferLeft = CODE_BUFFER_LEN;
    if( !ProcessKeyword( SegAttributes ) && !GotOvl ) {
        Warning( "no segment attributes specified", OPTION_SLOT );
    } else {    // get the rest of the attributes.
        while( ProcessKeyword( SegAttributes ) )
            {}     // NULL statement.
        if( BufferLeft != CODE_BUFFER_LEN && !GotOvl ) { // something spec'd.
            len = CODE_BUFFER_LEN - BufferLeft;
            result = MemAlloc( len + seglen + 12 );
            memcpy( result, "segment '", 9 );
            currloc = result + 9;
            memcpy( currloc, segname, seglen );
            currloc += seglen;
            *currloc++ = '\'';
            *currloc++ = ' ';
            memcpy( currloc, buffer, len );
            *(currloc + len) = '\0';
            AddCommand( result, OPTION_SLOT, false );
        }
    }
    MultiLine = GetSegments;
}
Exemplo n.º 12
0
void Scanner::IdentifyAndMake()
{
	TokenType t;
	TokenValue v;
	if (!reserved_words.Identify(buffer_low, t, v)) //如果不是保留字,注意在Identify函数中
	{                                               //用的是引用,所以会改变t,v的值
		t = IDENTIFIER;           //说明其实普通标识符
		v = TOK_UNRESERVED;       //值为不是保留字
	}
	MakeToken(t, v);
}
Exemplo n.º 13
0
bool Scanner::TryToIdentify()
{
	TokenType t;
	TokenValue v;
	if (reserved_words.Identify(buffer_low, t, v))
	{
		MakeToken(t, v);
		return true;
	}
	return false;
}
Exemplo n.º 14
0
static void SetWindows( void )
/****************************/
{
    unsigned long       bogus;

    FmtType = FMT_WINDOWS;
    if( !MakeToken( SEP_NO, FALSE ) ) return;
    if( !GetNumber( &bogus ) ) {
        CmdFile->current = CmdFile->token;      // reparse the token later
    }
}
Exemplo n.º 15
0
static void ProcDescription( void )
/*********************************/
{
    #define PREFIX      "description '"
    char        *msg;

    MakeToken( SEP_QUOTE, true );
    msg = alloca( CmdFile->len + sizeof( PREFIX ) + 1 );
    memcpy( msg, PREFIX, sizeof( PREFIX ) );
    memcpy( msg + sizeof( PREFIX ) - 1, CmdFile->token, CmdFile->len );
    strcpy( msg + sizeof( PREFIX ) - 1 + CmdFile->len, "'" );
    AddOption( msg );
}
Exemplo n.º 16
0
static void ProcStackSize( void )
/*******************************/
{
    unsigned long value;

    if( !MakeToken( SEP_NO, true ) ) {
        Warning( "argument for stacksize is invalid", OPTION_SLOT );
    } else if( !GetNumber( &value ) || value >= (64*1024UL) ) {
        Warning( "argument for stacksize is invalid", OPTION_SLOT );
    } else {
        AddNumOption( "stack", value );
    }
}
Exemplo n.º 17
0
static void ProcHeapsize( void )
/******************************/
{
    unsigned long value;

    if( !MakeToken( SEP_NO, true ) ) {
        Warning( "argument for heapsize not recognized", OPTION_SLOT );
    } else if( memicmp( CmdFile->token, "maxval", 6 ) == 0 ) {
        AddNumOption( "heapsize", 0xFFFF );
    } else if( !GetNumber( &value ) || value >= (64*1024UL) ) {
        Warning( "argument for heapsize not valid", OPTION_SLOT );
    } else {
        AddNumOption( "heapsize", value );
    }
}
Exemplo n.º 18
0
static bool ProcessKeyword( parse_entry *entry )
/**********************************************/
// returns true if keyword found.
{
    bool    ret;

    if( !MakeToken( SEP_NO, false ) ) {
        return( false );
    }
    ret = ProcessKeyList( entry, CmdFile->token, CmdFile->len );
    if( !ret ) {
        CmdFile->current = CmdFile->token;     // reparse the token later.
    }
    return( ret );
}
Exemplo n.º 19
0
void Scanner::AtInterger()
{
	while (isdigit(c))    //
	{
		AddToBuffer(c);
		ExtractChar();
	}
	/*if (tolower(c) == 'e' || (c == '.' && in.peek() != '.'))
	{
		AddToBuffer(c);
		ExtractChar();
		EatRealFractPart();
	}*/
	MakeToken(INT_CONST);          

}
Exemplo n.º 20
0
static void GetImport( void )
/***************************/
{
    char            *first;
    size_t          firstlen;
    char            *second;
    size_t          secondlen;
    unsigned long   value;
    char            *result;
    size_t          toklen;
    char            *currloc;

    if( !MakeToken( SEP_NO, false ) ) {
        Warning( "import library name is invalid", OPTION_SLOT );
        return;
    }
    DUPBUF_STACK( first, CmdFile->token, CmdFile->len );    // store it temporarily
    toklen = firstlen = CmdFile->len;
    second = NULL;
    secondlen = 0;
    if( MakeToken( SEP_EQUALS, false ) ) {        // got an internal name.
        DUPBUF_STACK( second, CmdFile->token, CmdFile->len );     // store it temporarily
        secondlen = CmdFile->len;
        toklen += secondlen + 1;                        // name & = sign.
    }
    if( !MakeToken( SEP_PERIOD, true ) ) {
        Warning( "import entry is invalid", OPTION_SLOT );
        return;
    }
    value = 0xFFFFF;      // arbitrary > 64k.
    if( GetNumber( &value ) ) {
        if( second == NULL ) {
            Warning("must have an internal name when an ordinal is specified", OPTION_SLOT );
            return;
        } else if( value >= (64*1024UL) ) {
            Warning( "import ordinal out of range", OPTION_SLOT );
            return;
        }
        toklen += 6;      // maximum size of ordinal + dot.
    } else {
        toklen += CmdFile->len + 1;      // string length + dot.
    }
    toklen += 8;       // import keyword + space + nullchar;
    result = MemAlloc( toklen );
    memcpy( result, "import ", 7 );
    currloc = result + 7;
    if( second != NULL ) {       // got a internal name in first.
        memcpy( currloc, first, firstlen );
        currloc += firstlen;
        first = second;         // make sure module name is in first.
        firstlen = secondlen;
    } else {
        memcpy( currloc, CmdFile->token, CmdFile->len );
        currloc += CmdFile->len;
    }
    *currloc++ = ' ';
    memcpy( currloc, first, firstlen );   // module name
    currloc += firstlen;
    if( value < (64*1024UL) ) {
        *currloc++ = '.';
        ultoa( value, currloc, 10 );
    } else {
        if( second != NULL ) {
            *currloc++ = '.';
            memcpy( currloc, CmdFile->token, CmdFile->len );
            currloc += CmdFile->len;
        }
        *currloc = '\0';
    }
    AddCommand( result, OPTION_SLOT, false );
}
Exemplo n.º 21
0
Token Scanner::GetNextToken()
{
	bool match = false;
	do
	{
		ExtractChar();   //从文件中获取一个字符                //列如 begin,首先c=b;加入缓冲区,重新读取c=e
		if (state != NONE_ST) match = true;                    //此时状态为标识符,则调用AtIdentifier
		switch (state)										  					
		{
		case IDENTIFIER_ST:
			AtIdentifier();
			break;
		case INTEGER_ST:
			AtInterger();
			break;
		case OPERATION_ST:
			AtOperation();
			break;
		case EOF_ST:
			MakeToken(END_OF_FILE);
			break;
		case NONE_ST:         //不做运算
			break;
		default:
			break;
		}
		if (state == NONE_ST)
		{
			AtLineComment();       //注释
			if (c == '\n')
			{
				++row;
				column= 0;
			}
			else
			{
				first_line= row;              //第几列
				first_pos = column;            //第几行
				if (in.eof())
				{
					state = EOF_ST;
				}
				else if (!isspace(c))         //空格
				{
					if (isalpha(c) || c == '_')     //字母或下划线开头
					{
						state = IDENTIFIER_ST;     //表明其实标识符
					}
					else if (isdigit(c))
					{
						state = INTEGER_ST;
					}
					else
					{
						state = OPERATION_ST;
					}
					AddToBuffer(c);
				}
			}
		}
	} while (!match);
	return token;
}
Exemplo n.º 22
0
static void SkipFunction( void )
/******************************/
// this skips a function name
{
    MakeToken( SEP_SPACE, true );       // skip a function name
}
Exemplo n.º 23
0
static void GetExport( void )
/***************************/
{
    char            *internal;
    size_t          intlen;
    char            *name;
    size_t          namelen;
    unsigned long   value;
    unsigned long   iopl;
    bool            isresident;
    bool            gottoken;
    bool            gotnodata;
    size_t          toklen;
    char            *command;
    char            *currloc;

    if( !MakeToken( SEP_NO, true ) ) {
        Warning( "invalid export name", OPTION_SLOT );
        return;
    }
    DUPBUF_STACK( name, CmdFile->token, CmdFile->len );            // store it temporarily
    toklen = namelen = CmdFile->len;
    internal = NULL;
    intlen = 0;
    if( MakeToken( SEP_EQUALS, true ) ) {                           // got an internal name.
        DUPBUF_STACK( internal, CmdFile->token, CmdFile->len );    // store it temporarily
        intlen = CmdFile->len;
        toklen += intlen + 1;                                       // +1 for = sign.
    }
    value = 0xFFFFF; // arbitrary >64K.
    if( MakeToken( SEP_AT, true ) ) {                               // got an ordinal.
        if( !GetNumber( &value ) || value > (64 * 1024UL) ) {
            Warning( "export ordinal value is invalid", OPTION_SLOT );
            return;
        } else {
            toklen += 6;                                            // maximum integer length + dot
        }
    }
    isresident = false;
    EatWhite();
    gottoken = MakeToken( SEP_NO, true );
    if( gottoken ) {
        if( CmdFile->len == 12 && memicmp( CmdFile->token, "residentname", 12 ) == 0 ) {
            isresident = true;
            gottoken = MakeToken( SEP_NO, true );
            toklen += 9;           // length of resident + space.
        }
    }
    gotnodata = false;
    if( gottoken ) {
        if( memicmp( CmdFile->token, "nodata", 6 ) == 0 ) {
            gottoken = MakeToken( SEP_NO, true );
            gotnodata = true;
        }
    }
    iopl = 1024;      // arbitrary > 63
    if( gottoken ) {
        if( !GetNumber( &iopl ) || iopl > 63 ) {
            Warning( "iopl value is invalid", OPTION_SLOT );
        } else {
            toklen += 3;    // maximum iopl length + space.
        }
        if( !gotnodata ) {
            gottoken = MakeToken( SEP_NO, true );
        }
    }
    if( gottoken && !gotnodata ) {
        if( memicmp( CmdFile->token, "nodata", 6 ) == 0 ) {
            gotnodata = true;
        } else {
            CmdFile->current = CmdFile->token;      // reparse the token later
        }
    }
    toklen += 8;       // export keyword + space + nullchar;
    command = MemAlloc( toklen );
    memcpy( command, "export ", 7 );
    currloc = command + 7;
    memcpy( currloc, name, namelen );
    currloc += namelen;
    if( value <= (64*1024UL) ) {   // if an ordinal was specified....
        *currloc++ = '.';
        ultoa( value, currloc, 10 );
        while( *currloc != '\0' ) {    // find end of string.
            currloc++;
        }
    }
    if( internal != NULL ) {
        *currloc++ = '=';
        memcpy( currloc, internal, intlen );
        currloc += intlen;
    }
    if( isresident ) {
        *currloc++ = ' ';
        memcpy( currloc, "resident", 8 );
        currloc += 8;
    }
    if( iopl <= 63 ) {
        *currloc++ = ' ';
        ultoa( iopl * 2, currloc, 10 ); // convert iopl value to a byte value
    } else {
        *currloc = '\0';
    }
    AddCommand( command, OPTION_SLOT, false );
}