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));
}
