private void AfterRootPrivacy(string word, int startPos, FunctionPrivacy privacy) { _code.SkipWhiteSpace(); var dataTypeStartPos = _code.Position; var dataType = DataType.TryParse(new DataType.ParseArgs { Code = _code, DataTypeCallback = GlobalDataTypeCallback, VariableCallback = GlobalVariableCallback }); if (dataType != null) { AfterRootDataType(dataType, dataTypeStartPos, privacy, false); } else if (_code.ReadWord()) { var funcName = _code.Text; var funcNameSpan = _code.Span; if (_code.ReadExact('(')) { StartFunctionArgs(funcName, startPos, _code.TokenStartPostion, funcNameSpan, DataType.Int, privacy, false); } } }
public FunctionSignature(bool isExtern, FunctionPrivacy privacy, DataType returnDataType, string className, string funcName, string devDesc, IEnumerable <ArgumentDescriptor> args) { _extern = isExtern; _privacy = privacy; _returnDataType = returnDataType; _className = className; _funcName = funcName; _devDesc = devDesc; _args = args.ToArray(); }
private void AfterRootDataType(DataType dataType, int dataTypeStartPos, FunctionPrivacy privacy, bool isExtern) { #if DEBUG if (dataType == null) { throw new ArgumentNullException("dataType"); } #endif if (_code.ReadWord()) { var name = _code.Text; var nameSpan = _code.Span; var arrayLength = TryReadArrayDecl(); if (arrayLength == null && _code.ReadExact('(')) { StartFunctionArgs(name, dataTypeStartPos, _code.TokenStartPostion, nameSpan, dataType, privacy, isExtern); } else if (_code.ReadExact(';')) { var localPos = _source.GetFilePosition(nameSpan.Start); var def = new VariableDefinition(name, localPos, dataType, false, arrayLength, VariableType.Global); _globalVars[name] = def; AddGlobalDefinition(def); } else if (_code.ReadExact(',')) { var localPos = _source.GetFilePosition(nameSpan.Start); var def = new VariableDefinition(name, localPos, dataType, false, arrayLength, VariableType.Global); _globalVars[name] = def; AddGlobalDefinition(def); AfterRootDataType(dataType, dataTypeStartPos, privacy, isExtern); } } }
private void StartFunctionArgs(string funcName, int allStartPos, int argStartPos, Span nameSpan, DataType returnDataType, FunctionPrivacy privacy, bool isExtern) { var localArgStartPos = _source.GetFilePosition(argStartPos); var argScope = new CodeScope(localArgStartPos.Position); int argEndPos = 0; var args = new List <ArgumentDescriptor>(); var argDefList = new List <Definition>(); // Read the arguments while (true) { if (_code.ReadExact(')')) { argEndPos = _code.Position; break; } if (_code.ReadExact(',')) { continue; } if (TryReadFunctionArgument(argScope, !_visible || localArgStartPos.PrimaryFile, args, argDefList)) { continue; } return; } int bodyStartPos; string description; if (!ReadFunctionAttributes(funcName, out bodyStartPos, out description, isExtern)) { return; } if (isExtern) { var localPos = _source.GetFilePosition(nameSpan.Start); var sig = new FunctionSignature(true, privacy, returnDataType, _className, funcName, description, args); sig.ApplyDocumentation(localPos.FileName); var def = new FunctionDefinition(sig, localPos, 0, 0, 0, Span.Empty); _externFuncs[funcName] = def; AddGlobalDefinition(def); return; } // Read the variables at the start of the function. var localBodyStartPos = _source.GetFilePosition(bodyStartPos); CodeScope funcScope = null; var varList = new List <Definition>(); if (!_visible || localBodyStartPos.PrimaryFile) // Don't worry about saving variables if this function isn't in this file anyway. { funcScope = new CodeScope(argScope, bodyStartPos); while (!_code.EndOfFile) { if (!TryReadVariableDeclaration(funcScope, varList)) { break; } } //// Add the arguments to the body as well, so they are accessible inside the function. //foreach (var def in argDefList) //{ // _defProv.AddLocalDefinition(localBodyStartPos.Position, def); //} } var statementsStartPos = _code.Position; ReadFunctionBody(); var bodyEndPos = _code.Position; var bodyStartLocalPos = _source.GetPrimaryFilePosition(bodyStartPos); var nameActualPos = _source.GetFilePosition(nameSpan.Start); var argStartPrimaryPos = _source.GetPrimaryFilePosition(argStartPos); var argEndPrimaryPos = _source.GetPrimaryFilePosition(argEndPos); var entireSpan = _source.GetPrimaryFileSpan(new Span(allStartPos, bodyEndPos)); var funcDef = new FunctionDefinition(new FunctionSignature(false, privacy, returnDataType, _className, funcName, description, args), nameActualPos, argStartPrimaryPos, argEndPrimaryPos, bodyStartLocalPos, entireSpan); _localFuncs.Add(new LocalFunction(funcDef, nameSpan, statementsStartPos, bodyEndPos, argDefList, varList)); AddGlobalDefinition(funcDef); // Add the definitions for the argument list Span argEffect; if (_visible) { argEffect = new Span(localArgStartPos.Position, _source.GetPrimaryFilePosition(bodyEndPos)); } else { argEffect = new Span(argStartPos, bodyEndPos); } _defProv.AddLocal(argEffect, argDefList); // Add the definitions for the declared variables if (varList != null) { Span varEffect; if (_visible) { varEffect = new Span(bodyStartLocalPos, _source.GetPrimaryFilePosition(bodyEndPos)); } else { varEffect = new Span(bodyStartPos, bodyEndPos); } _defProv.AddLocal(varEffect, varList); } }
public static FunctionSignature ParseFromDb(string str) { var code = new CodeParser(str); bool isExtern = false; FunctionPrivacy privacy = FunctionPrivacy.Public; DataType returnDataType = null; string className = null; string funcName = string.Empty; string devDesc = null; var args = new List <ArgumentDescriptor>(); var stopParsing = false; while (code.ReadWord() && !stopParsing) { switch (code.Text) { case "ext": isExtern = true; break; case "priv": privacy = FunctionPrivacy.Private; break; case "prot": privacy = FunctionPrivacy.Protected; break; case "rdt": if (!code.ReadStringLiteral()) { Log.Debug("Unable to read return data type from: {0}", str); } else { var dtString = CodeParser.StringLiteralToString(code.Text); returnDataType = DataType.TryParse(new DataType.ParseArgs { Code = new CodeParser(dtString) }); if (returnDataType == null) { Log.Debug("Unable to parse return data type from: {0}", dtString); returnDataType = new DataType(ValType.Unknown, null, new Classifier.ProbeClassifiedString(Classifier.ProbeClassifierType.DataType, dtString)); } } break; case "cls": if (!code.ReadWord()) { Log.Debug("Unable to read class name from: {0}", str); } else { className = code.Text; } break; case "fn": if (!code.ReadWord()) { Log.Debug("Unable to read function name from: {0}", str); } else { funcName = code.Text; } break; case "desc": if (!code.ReadStringLiteral()) { Log.Debug("Unable to read description from: {0}", str); } else { devDesc = CodeParser.StringLiteralToString(code.Text); } break; case "arg": if (!code.ReadStringLiteral()) { Log.Debug("Unable to read return data type from: {0}", str); } else { var argString = CodeParser.StringLiteralToString(code.Text); var arg = ArgumentDescriptor.ParseFromDb(argString); if (arg == null) { Log.Debug("Unable to parse argument from: {0}", argString); } else { args.Add(arg); } } break; default: Log.Debug("Unexpected word '{0}' in function signature: {1}", code.Text, str); stopParsing = true; break; } } return(new FunctionSignature(isExtern, privacy, returnDataType, className, funcName, devDesc, args)); }