//exit function prototype scope
public static void EndFunctionDeclarator(bool isPointer, int numParam)
{
CIdentifier.ExitFunctionPrototypeScope();
CDeclarator old = PopDeclarator();
List <CParamater> Params = new List <CParamater>();
for (int i = 0; i < numParam; i++)
{
Params.Add(PopParam());
}
CDeclarator result = new CDeclarator();
result.Identifer = old.Identifer;
result.TypeModifier = CTypeModifier.FunctionModifier(Params).ModifyModifier(old.TypeModifier);
if (isPointer)
{
result.TypeModifier = PopPointerModifier().ModifyModifier(result.TypeModifier);
}
PushDeclarator(result);
}
public static void PushIdentifierDeclarator(bool isPointer, string idString)
{
CDeclarator decltor = new CDeclarator();
decltor.Identifer = idString;
decltor.TypeModifier = isPointer ? PopPointerModifier() : null;
PushDeclarator(decltor);
}
// has a (declarator) in it
public static void NestedDeclarator(bool isPointer)
{
CDeclarator decltor = new CDeclarator();
var old = PopDeclarator();
decltor.Identifer = old.Identifer;
decltor.TypeModifier = isPointer ? PopPointerModifier().ModifyModifier(old.TypeModifier) : old.TypeModifier;
PushDeclarator(decltor);
}
// declarators
/*Declarators
* Each declarator is one of the following:
*
* identifier (1)
*
* ( declarator ) (2)
*
* * qualifiers(optional) declarator (3)
*
* noptr-declarator [ static(optional) qualifiers(optional) expression ]
* noptr-declarator [ qualifiers(optional) * ] (4)
*
* noptr-declarator ( parameters-or-identifiers ) (5)
*
* 1) the identifier that this declarator introduces.
*
* 2) any declarator may be enclosed in parentheses;
* this is required to introduce pointers to arrays and pointers to functions.
*
* 3) pointer declarator:
* the declaration S * cvr D; declares D as a pointer to the type determined by S. (THIS IS SUCH A CRUFYFT PART OF C. WHY THE HELL IS POINTER A PART OF THE DECLARATOR, AND NOT THE TYPE)
*
* 4) array declarator: the declaration S D[N] declares D as an array of N objects of the type determined by S.
* noptr-declarator is any other declarator except unparenthesized pointer declarator. (THIS IS SUCH A CRUFYFT PART OF C. WHY THE HELL IS ARRAY A PART OF THE DECLARATOR, AND NOT THE TYPE)
*
* 5) function declarator: the declaration S D(params) declared D as a function taking the parameters params and returning S.
* noptr-declarator is any other declarator except unparenthesized pointer declarator.
*
* initilization
* http://en.cppreference.com/w/c/language/initialization
*
* A declaraton of an object may provide its initial value through the process known as initialization.
* For each declarator, the initializer, if not omitted, may be one of the following:
*
* = expression (1) (scalar initilization)
* = { initializer-list } (2) (array initilization)
*
* where initializer-list is a non-empty comma-separated list of initializers (with an optional trailing comma),
* where each initializer has one of two possible forms:
* expression (1) (value)
* { initializer-list } (2) (nested array)
*
* Scalar initialization
* When initializing an object of scalar type, the initializer must be a single expression
* The initializer for a scalar must be a single expression, optionally enclosed in braces
* The expression is evaluated, and its value, after conversion as if by assignment to the type of the object, becomes the initial value of the object being initialized.
* As with all other initializations, expression must be a constant expression when initializing objects of static or thread-local storage duration.
*
* Array initialization
* see http://en.cppreference.com/w/c/language/array_initialization
* summary, i dont support init from a string. must init from list
* init from list works how you expect
* no supprot for desegnators
*/
public static void DeclaratorWithInitilizer()
{
CDeclarator decltor = new CDeclarator();
var old = PopDeclarator();
decltor.TypeModifier = old.TypeModifier;
decltor.Identifer = old.Identifer;
decltor.Init = inits.Pop();
PushDeclarator(decltor);
}
//exit function scope
public static void EndFunctionDefinition(int numSpecifiers)
{
CIdentifier.ExitFunctionScope();
List <CDeclarationSpecifier> specs = new List <CDeclarationSpecifier>();
for (int i = 0; i < numSpecifiers; i++)
{
specs.Add(PopDeclSpec());
}
CDeclarationSpecifier typeSpec = specs.First(spec => spec.SpeciferType == CDeclarationSpecifierType.Type);
CDeclarationSpecifier storageClass = specs.FirstOrDefault(spec => spec.SpeciferType == CDeclarationSpecifierType.Storage);
CDeclarator paramDecl = PopDeclarator();
CIdentifier.DefineFunction(paramDecl.TypeModifier.ModifyType(typeSpec.type), paramDecl.Identifer, storageClass == null ? CStorageClass.Ignore : storageClass.StorageClass);
}
//paramaters
//define param in function scope or function prototype scope
public static void ParamaterDeclaration(int numSpecifiers)
{
List <CDeclarationSpecifier> specs = new List <CDeclarationSpecifier>();
for (int i = 0; i < numSpecifiers; i++)
{
specs.Add(PopDeclSpec());
}
CDeclarationSpecifier typeSpec = specs.First(spec => spec.SpeciferType == CDeclarationSpecifierType.Type);
//ignore const and register specifiers on params
CDeclarator declarator = PopDeclarator();
CParamater param = CIdentifier.CreateFunctionParameter(
declarator.Identifer,
declarator.TypeModifier != null ? declarator.TypeModifier.ModifyType(typeSpec.type) : typeSpec.type
);
PushParam(param);
}
public static void ArrayDeclarator(bool isPointer, int numTypeQualifiers, bool hasAssgnExpr)
{
CDeclarator old = PopDeclarator();
CExpression assgn = hasAssgnExpr ? CExpression.PopExpression() : null;
List <CDeclarationSpecifier> qualifiers = new List <CDeclarationSpecifier>();
for (int i = 0; i < numTypeQualifiers; i++)
{
qualifiers.Add(PopDeclSpec());
}
CDeclarator result = new CDeclarator();
result.Identifer = old.Identifer;
result.TypeModifier = CTypeModifier.ArrayModifier(qualifiers, assgn).ModifyModifier(old.TypeModifier);
if (isPointer)
{
result.TypeModifier = PopPointerModifier().ModifyModifier(result.TypeModifier);
}
PushDeclarator(result);
}
private static void PushDeclarator(CDeclarator declarator)
{
declarators.Push(declarator);
}
