Esempio n. 1
0
 public SplitExpression(Token splitOperator, Expression leftHandSide, Expression rightHandSide, Expression completeExpression)
     : base(completeExpression)
 {
     this.Operator = splitOperator;
     this.LeftHandSide = leftHandSide;
     this.RightHandSide = rightHandSide;
 }
Esempio n. 2
0
        private void ParseAndAddFunctionDefinition(Token variableType, Token variableName, bool isMemberFunction)
        {
            if (isMemberFunction)
            {
                VerifyModifiersAgainstType(ModifierTargets.MemberFunction);
            }
            else
            {
                VerifyModifiersAgainstType(ModifierTargets.GlobalFunction);
            }
            VerifyReturnTypeValidForFunction(variableType);

            ScriptFunction func = new ScriptFunction(variableType, variableName);
            ParseFunctionParameterList(func);

            if (_source.NextIsKeyword(PredefinedSymbol.Semicolon))
            {
                func.IsPrototypeOnly = true;
            }
            else
            {
                if (func.IsPrototypeOnly == true)
                {
                    throw new CompilerMessage(ErrorCode.AnonymousParameterInFunctionBody, "One or more parameters did not have a name");
                }

                func.IsPrototypeOnly = false;
                _state.NextTokenModifiers.Clear();
                ProcessFunctionBody();
            }
        }
Esempio n. 3
0
 public Token Clone()
 {
     Token copy = new Token(_name);
     copy._defined = this._defined;
     copy._isVariableType = this._isVariableType;
     copy._isArray = this._isArray;
     copy._arraySize = this._arraySize;
     copy._type = this._type;
     copy._value = this._value;
     return copy;
 }
Esempio n. 4
0
		private void ProcessTokenAtTopLevel(Token thisToken)
		{
			if (thisToken is ModifierToken)
			{
				_state.NextTokenModifiers.Add((ModifierToken)thisToken);
			}
			else if (thisToken.IsVariableType)
			{
                bool wasFunction = false;
				do
				{
					wasFunction = ParseAndAddGlobalVariableOrFunction(thisToken);
				}
				while ((!wasFunction) && (_source.NextIsKeyword(PredefinedSymbol.Comma)));

                if (!wasFunction)
                {
                    _source.ExpectKeyword(PredefinedSymbol.Semicolon);
                }
				_state.NextTokenModifiers.Clear();
			}
			else if (thisToken is KeywordToken)
			{
				PredefinedSymbol keyword = ((KeywordToken)thisToken).SymbolType;
				if (keyword == PredefinedSymbol.StructDefinition)
				{
					_output.AddStruct(ProcessStructDeclaration());
				}
				else if (keyword == PredefinedSymbol.Enum)
				{
					ProcessEnumDeclaration();
				}
                else if (keyword == PredefinedSymbol.Export)
                {
                    ProcessExportCommand();
                }
                else
                {
                    RecordError(ErrorCode.InvalidUseOfKeyword, "Invalid use of '" + thisToken.Name + "'");
                }
			}
            else if (thisToken.Name.StartsWith(Constants.NEW_SCRIPT_MARKER))
			{
                _scriptName = thisToken.Name.Substring(Constants.NEW_SCRIPT_MARKER.Length, thisToken.Name.Length - Constants.NEW_SCRIPT_MARKER.Length - 1);
			}
			else
			{
				RecordError(ErrorCode.UnexpectedToken, "Unexpected '" + thisToken.Name + "'");
			}
		}
Esempio n. 5
0
        public static void SetArrayPropertiesOnTokenFromStream(ScriptReader source, Token variableName)
        {
            if (source.NextIsKeyword(PredefinedSymbol.OpenSquareBracket))
            {
                variableName.IsArray = true;

                if (source.NextIsKeyword(PredefinedSymbol.CloseSquareBracket))
                {
                    variableName.ArraySize = Token.ARRAY_SIZE_DYNAMIC;
                }
                else
                {
                    variableName.ArraySize = source.ReadNextAsConstInt();
                    source.ExpectKeyword(PredefinedSymbol.CloseSquareBracket);
                }
            }
        }
Esempio n. 6
0
        private void DeclareLocalVariable(Token variableType)
        {
            _source.IgnoreAsteriskIfPresent();

            Token variableName = _source.ReadNextTokenAndThrowIfAlreadyDefined();

            CompilerUtils.SetArrayPropertiesOnTokenFromStream(_source, variableName);

            CompilerUtils.VerifyModifiersAgainstType(ModifierTargets.LocalVariable, _state.NextTokenModifiers);
            /* TODO: get this working
            ScriptVariable newVariable = ProcessVariableDeclaration(variableType, _output.GlobalData, null, _state.NextTokenModifiers);

            variableName.Define(TokenType.LocalVariable, newVariable); */

            if (_source.NextIsKeyword(PredefinedSymbol.SetEqual))
            {
                Expression setEqualTo = ReadExpression(false, PredefinedSymbol.Semicolon, PredefinedSymbol.Comma);
                // TODO: check types, assign result to variable
            }
        }
Esempio n. 7
0
 public static bool AdjustBracketLevelIfTokenIsBracket(Token token, ref int bracketLevel)
 {
     if (token is KeywordToken)
     {
         PredefinedSymbol symbol = ((KeywordToken)token).SymbolType;
         if ((symbol == PredefinedSymbol.OpenBrace) ||
             (symbol == PredefinedSymbol.OpenParenthesis) ||
             (symbol == PredefinedSymbol.OpenSquareBracket))
         {
             bracketLevel++;
             return true;
         }
         else if ((symbol == PredefinedSymbol.CloseBrace) ||
             (symbol == PredefinedSymbol.CloseParenthesis) ||
             (symbol == PredefinedSymbol.CloseSquareBracket))
         {
             bracketLevel--;
             return true;
         }
     }
     return false;
 }
Esempio n. 8
0
        public bool HasNonImportedMemberOfType(Token tokenToLookFor)
        {
            foreach (ScriptVariable member in Members)
            {
                if (member.VariableTypeToken == tokenToLookFor)
                {
                    bool thisOneIsOk = true;

                    if ((member is FixedOffsetVariable) &&
                        (((FixedOffsetVariable)member).IsAttributeProperty))
                    {
                        thisOneIsOk = false;
                    }

                    if (thisOneIsOk)
                    {
                        return true;
                    }
                }
            }
            return false;
        }
Esempio n. 9
0
 public static Token GetTokenForStructMember(TokenizedScript script, Token structName, Token memberName, out string mangledName)
 {
     mangledName = structName.Name + "::" + memberName.Name;
     return script.FindTokenWithName(mangledName);
 }
Esempio n. 10
0
 private void VerifyReturnTypeValidForFunction(Token returnType)
 {
     if (returnType.Type == TokenType.StructType)
     {
         if (!returnType.StructType.IsManaged)
         {
             throw new CompilerMessage(ErrorCode.CannotReturnStructFromFunction, "Cannot return a non-managed struct from a function");
         }
     }
 }
Esempio n. 11
0
 public void AddToken(Token tokenToAdd)
 {
     _tokens.Add(tokenToAdd.Name, tokenToAdd);
 }
Esempio n. 12
0
		private void ParseAndAddMemberToStruct(Token variableType, Token structName, ScriptStruct structDefinition, Token parentStruct)
		{
            _source.IgnoreAsteriskIfPresent();
			Token memberName = _source.ReadNextToken();
            if ((memberName is KeywordToken) || (memberName is OperatorToken) ||
                (memberName is ModifierToken))
            {
                throw new CompilerMessage(ErrorCode.TokenAlreadyDefined, "Cannot use '" + memberName.Name + "' as variable name since it has another meaning");
            }

            string mangledName;
            memberName = GetTokenForStructMember(structName, memberName, out mangledName);
			if (memberName != null)
			{
				throw new CompilerMessage(ErrorCode.TokenAlreadyDefined, "Member '" + mangledName + "' already exists");
			}
			memberName = new Token(mangledName, true);
			// TODO: Set necessary fields on new token for this struct member
			_tokenizedScript.AddToken(memberName);

			CompilerUtils.SetArrayPropertiesOnTokenFromStream(_source, memberName);

			if (_source.NextIsKeyword(PredefinedSymbol.OpenParenthesis))
			{
                VerifyModifiersAgainstType(ModifierTargets.MemberFunction);
                VerifyReturnTypeValidForFunction(variableType);

                ScriptFunction func = new ScriptFunction(variableType, memberName);
                ParseFunctionParameterList(func);

                func.IsPrototypeOnly = true;
            }
			else
			{
                VerifyModifiersAgainstType(ModifierTargets.MemberVariable);
                ProcessVariableDeclaration(variableType, structDefinition, parentStruct, _state.NextTokenModifiers);
			}
		}
Esempio n. 13
0
 private void VerifyParameterTypeValidForFunction(Token parameterType)
 {
     if (parameterType.Type == TokenType.StructType)
     {
         if (!parameterType.StructType.IsManaged)
         {
             throw new CompilerMessage(ErrorCode.CannotPassStructToFunction, "Cannot pass a non-managed struct to a function");
         }
     }
 }
Esempio n. 14
0
		private bool ParseAndAddGlobalVariableOrFunction(Token variableType)
		{
            bool isMemberFunctionBody = false;

            _source.IgnoreAsteriskIfPresent();
            FixedOffsetVariable importedVersion = null;
            Token variableName = _source.ReadNextToken();

            if ((variableName.Type == TokenType.GlobalVariable) &&
                (variableName.Variable.IsImported) &&
                (!variableName.Variable.IsAccessed))
            {
                importedVersion = variableName.Variable;
            }
            else
            {
                ReadNameOfNewGlobalVariableOrFunction(variableName, out isMemberFunctionBody);
            }

			if (_source.NextIsKeyword(PredefinedSymbol.OpenParenthesis))
			{
                ParseAndAddFunctionDefinition(variableType, variableName, isMemberFunctionBody);
                return true;
			}
			else
			{
                CompilerUtils.SetArrayPropertiesOnTokenFromStream(_source, variableName);
                ParseAndAddGlobalVariableDefinition(variableType, variableName, importedVersion);
			}

            return false;
		}
Esempio n. 15
0
        private void ParseAndAddGlobalVariableDefinition(Token variableType, Token variableName, FixedOffsetVariable importedVersion)
        {
            VerifyModifiersAgainstType(ModifierTargets.GlobalVariable);
            FixedOffsetVariable newVariable = ProcessVariableDeclaration(variableType, _output.GlobalData, null, _state.NextTokenModifiers);
            variableName.Define(TokenType.GlobalVariable, newVariable);
            if (_source.NextIsKeyword(PredefinedSymbol.SetEqual))
            {
                // TODO: Check types to ensure this is valid
                newVariable.DefaultValue = _source.ReadNextAsConstInt();
            }

            if (importedVersion != null)
            {
                if (importedVersion.CompareTo(newVariable) != 0)
                {
                    throw new CompilerMessage(ErrorCode.NewDefinitionIsDifferent, "New definition of '" + variableName.Name + "' does not match previous one");
                }
            }
        }
Esempio n. 16
0
        private void ReadNameOfNewGlobalVariableOrFunction(Token variableName, out bool isMemberFunctionBody)
        {
            isMemberFunctionBody = false;

            if (variableName.Type == TokenType.StructType)
            {
                // Defining the body of a member function, eg. function Struct::function()
                _source.ExpectKeyword(PredefinedSymbol.MemberOf);

                Token memberName = _source.ReadNextToken();

                string mangledName;
                Token memberFunc = GetTokenForStructMember(variableName, memberName, out mangledName);
                if (memberFunc == null)
                {
                    throw new CompilerMessage(ErrorCode.MemberFunctionNotDefined, "Struct '" + variableName.Name + "' has no member function '" + memberName.Name + "'");
                }

                // TODO: Verify that memberFunc is a function not a variable
                // TODO: Verify that function arguments match prototype

                variableName = memberFunc;
                isMemberFunctionBody = true;
            }
            else if (variableName.Defined)
            {
                throw new CompilerMessage(ErrorCode.TokenAlreadyDefined, "Token '" + variableName.Name + "' is already defined");
            }
        }
Esempio n. 17
0
        private FixedOffsetVariable ProcessVariableDeclaration(Token variableType, DataGroup container, Token parent, Modifiers modifiers)
        {
            FixedOffsetVariable newVariable;
            int thisSize = 0;
            if (variableType.Type == TokenType.StructType)
            {
                ScriptStruct childStruct = (ScriptStruct)variableType.Value;
                if (childStruct.IsManaged)
                {
                    thisSize = FixedOffsetVariable.POINTER_SIZE_IN_BYTES;
                    newVariable = new FixedOffsetVariable(variableType, container.SizeInBytes, true);

                    if ((childStruct != container) &&
                        (parent != null) &&
                        (childStruct.HasNonImportedMemberOfType(parent)))
                    {
                        throw new CompilerMessage(ErrorCode.CircularReference, "The type '" + childStruct.Name + "' has a reference to this struct, so you cannot also have a reference this way round");
                    }
                }
                else if (childStruct == container)
                {
                    throw new CompilerMessage(ErrorCode.StructInsideItself, "A struct cannot be contained within itself");
                }
                else
                {
                    thisSize = childStruct.SizeInBytes;
                    newVariable = new FixedOffsetVariable(variableType, container.SizeInBytes, thisSize);
                }
            }
            else if (variableType is ScalarVariableTypeToken)
            {
                thisSize = ((ScalarVariableTypeToken)variableType).SizeInBytes;
                newVariable = new FixedOffsetVariable(variableType, container.SizeInBytes, thisSize);
            }
            else if (variableType.Type == TokenType.EnumType)
            {
                thisSize = FixedOffsetVariable.ENUM_SIZE_IN_BYTES;
                newVariable = new FixedOffsetVariable(variableType, container.SizeInBytes, thisSize);
            }
            else
            {
                throw new CompilerMessage(ErrorCode.CannotUseTypeInStruct, "Cannot add variable of type '" + variableType.Name + "' to struct");
            }
            newVariable.IsAttributeProperty = modifiers.HasModifier(Modifiers.ATTRIBUTE);
            newVariable.IsImported = modifiers.HasModifier(Modifiers.IMPORT);

            if ((newVariable.IsAttributeProperty) &&
                (!newVariable.IsImported))
            {
                throw new CompilerMessage(ErrorCode.AttributesMustBeImported, "Attribute types must be imported");
            }

            if ((newVariable.IsImported) &&
                (!newVariable.IsAttributeProperty) &&
                (parent != null))
            {
                throw new CompilerMessage(ErrorCode.InvalidUseOfKeyword, "'import' is invalid in this context");
            }

            if (newVariable.IsImported)
            {
                // No memory needed for imported vars
                newVariable.Offset = 0;
                thisSize = 0;
            }

            container.Members.Add(newVariable);
            container.SizeInBytes += thisSize;
            return newVariable;
        }
Esempio n. 18
0
 public ScriptFunction(Token returnType, Token name)
 {
     ReturnType = returnType;
     Name = name;
     Parameters = new List<FunctionParameter>();
 }
Esempio n. 19
0
 public FunctionParameter(Token type, Token name)
 {
     Type = type;
     Name = name;
 }
Esempio n. 20
0
 private Token GetTokenForStructMember(Token structName, Token memberName, out string mangledName)
 {
     return CompilerUtils.GetTokenForStructMember(_tokenizedScript, structName, memberName, out mangledName);
 }