protected Type TypeFromDeclarator(Declarator decl, Type baseType) { var source = decl.Source; var ty = baseType; while (decl is not SimpleDeclarator) { switch (decl) { case ArrayDeclarator when ty is RefType: Diagnostics.AddError($"Array of references is not valid", source); return(baseType); case ArrayDeclarator d: ty = new UnresolvedArrayType(ty, d.Length); decl = d.Inner; break; case RefDeclarator when ty is RefType: Diagnostics.AddError($"Reference to reference is not valid", source); return(baseType); case RefDeclarator d: ty = new RefType(ty); decl = d.Inner; break; default: throw new NotImplementedException(); } ; } return(ty); }
public FuncDef( DeclSpecs specifiers, Declarator declarator, IEnumerable <Declaration> declarations, CompoundStmt statement ) { this.specifiers = specifiers; this.declarator = declarator; this.declarations = declarations; this.body = statement; }
bool HasStronglyBoundPointer(Declarator d) { if (d == null) { return(false); } else if (d is PointerDeclarator && ((PointerDeclarator)d).StrongBinding) { return(true); } else { return(HasStronglyBoundPointer(d.InnerDeclarator)); } }
FunctionDeclarator GetFunctionDeclarator(Declarator d) { if (d == null) { return(null); } else if (d is FunctionDeclarator) { return((FunctionDeclarator)d); } else { return(GetFunctionDeclarator(d.InnerDeclarator)); } }
Declarator FixPointerAndArrayPrecedence(Declarator d) { if (d is PointerDeclarator && d.InnerDeclarator != null && d.InnerDeclarator is ArrayDeclarator) { var a = d.InnerDeclarator; var p = d; var i = a.InnerDeclarator; a.InnerDeclarator = p; p.InnerDeclarator = i; return(a); } else { return(null); } }
Declarator MakeArrayDeclarator(Declarator left, TypeQualifiers tq, Expression len, bool isStatic) { var a = new ArrayDeclarator(); a.LengthExpression = len; if (left.StrongBinding) { var i = left.InnerDeclarator; a.InnerDeclarator = i; left.InnerDeclarator = a; return(left); } else { a.InnerDeclarator = left; return(a); } }
private CType MakeCFunctionType(CType type, Declarator decl) { var fdecl = (FunctionDeclarator)decl; var name = decl.DeclaredIdentifier; var returnType = type; var ftype = new CFunctionType(returnType); foreach (var pdecl in fdecl.Parameters) { var pt = MakeCType(pdecl.DeclarationSpecifiers, pdecl.Declarator); if (!pt.IsVoid) { ftype.Parameters.Add(new CFunctionType.Parameter(pdecl.Name, pt)); } } type = ftype; type = MakeCType(type, fdecl.InnerDeclarator); return(type); }
public Declarator ArrayDeclarator(Declarator decl, CExpression expr) { return new ArrayDeclarator { Declarator = decl, Size = expr }; }
public InitDeclarator InitDeclarator(Declarator decl, Initializer init) { return new InitDeclarator { Declarator = decl, Init = init }; }
public ParamDecl ParamDecl(List<DeclSpec> dsl, Declarator decl) { return new ParamDecl { DeclSpecs = dsl, Declarator = decl, }; }
public FieldDeclarator FieldDeclarator(Declarator decl, CExpression bitField) { return new FieldDeclarator { Declarator = decl, FieldSize = bitField }; }
public Declaration(DeclarationSpecifiers specs, Declarator decl, Initializer init) { Specifiers = specs; Declarator = decl; Initializer = init; }
internal Decl FunctionDefinition(List<DeclSpec> decl_spec_list, Declarator declarator, List<Stat> statements) { return new FunctionDecl { decl_specs = decl_spec_list, //$REVIEW: dupe? Signature = Decl(decl_spec_list, declarator), Body = statements }; }
public Declarator CallConventionDeclarator(CTokenType conv, Declarator decl) { return new CallConventionDeclarator { Convention = conv, Declarator = decl, }; }
public ArrayDeclarator(Declarator inner, Expression length, SourceRange source) : base(source) => (Inner, Length) = (inner, length);
public ParameterDecl(DeclarationSpecifiers specs, Declarator dec) { DeclarationSpecifiers = specs; Name = dec.DeclaredIdentifier; Declarator = dec; }
CType MakeCType(CType type, Declarator decl) { if (decl is IdentifierDeclarator) { // This is the name } else if (decl is PointerDeclarator) { var pdecl = (PointerDeclarator)decl; var isPointerToFunc = false; if (pdecl.StrongBinding) { type = MakeCType(type, pdecl.InnerDeclarator); isPointerToFunc = type is CFunctionType; } var p = pdecl.Pointer; while (p != null) { type = new CPointerType(type); type.TypeQualifiers = p.TypeQualifiers; p = p.NextPointer; } if (!pdecl.StrongBinding) { type = MakeCType(type, pdecl.InnerDeclarator); } // // Remove 1 level of pointer indirection if this is // a pointer to a function since functions are themselves // pointers // if (isPointerToFunc) { type = ((CPointerType)type).InnerType; } } else if (decl is ArrayDeclarator) { var adecl = (ArrayDeclarator)decl; while (adecl != null) { type = new CArrayType(type, adecl.LengthExpression); adecl = adecl.InnerDeclarator as ArrayDeclarator; if (adecl != null && adecl.InnerDeclarator != null) { if (adecl.InnerDeclarator is IdentifierDeclarator) { } else if (!(adecl.InnerDeclarator is ArrayDeclarator)) { type = MakeCType(type, adecl.InnerDeclarator); } else { //throw new NotSupportedException("Unrecognized array syntax"); } } } } else if (decl is FunctionDeclarator) { type = MakeCFunctionType(type, decl); } return(type); }
CType MakeCType(DeclarationSpecifiers specs, Declarator decl) { var type = MakeCType(specs); return(MakeCType(type, decl)); }
public Declaration(string type, Declarator declarator, Expression?initializer, SourceRange source) : base(source) => (Type, Declarator, Initializer) = (type, declarator, initializer);
public Declarator FunctionDeclarator(Declarator decl, List<ParamDecl> parameters) { return new FunctionDeclarator { Declarator = decl, Parameters = parameters }; }
/// <summary> /// Get hash code /// </summary> public override int GetHashCode() { return(Declarator.GetHashCode() ^ Initializer.GetHashCode()); }
public Declarator PointerDeclarator(Declarator decl, List<TypeQualifier> tqs) { return new PointerDeclarator { TypeQualifierList = tqs, Pointee = decl}; }
public void AddDeclarator (Declarator decl) { if (declarators == null) declarators = new List<Declarator> (); declarators.Add (decl); }
internal Decl Decl(List<DeclSpec> list, Declarator decl) { return new Decl { decl_specs = list, init_declarator_list = new List<InitDeclarator> { new InitDeclarator { Declarator = decl, Init= null } } }; }
internal Decl Decl(List<CAttribute> attrs, List<DeclSpec> list, Declarator decl) { return new Decl { attribute_list = attrs, decl_specs = list, init_declarator_list = new List<InitDeclarator> { new InitDeclarator { Declarator = decl, Init= null } } }; }
public static void SetDeclarationRules() { // declaration // : declaration-specifiers [Init-declarator-list]? ';' Declaration.Is( (DeclarationSpecifiers) .Then(InitDeclaratorList.Optional(ImmutableList <InitDeclr> .Empty)) .Then(Semicolon) .Then(Decln.Create) .TransformResult( _ => { var result = _.Result; var env = _.Environment; env = result.InitDeclrs.Aggregate(env, (currentEnv, initDeclr) => currentEnv.AddSymbol( initDeclr.Declr.Name, result.DeclnSpecs.StorageClsSpecs.DefaultIfEmpty(StorageClsSpec.AUTO).First() ) ); return(ParserSucceeded.Create(result, env, _.Source)); } ) ); // declaration-specifiers // : [ storage-class-specifier | Type-specifier | Type-qualifier ]+ DeclarationSpecifiers.Is( Parser.Seed(DeclnSpecs.Empty) .Then( Either( Given <DeclnSpecs>() .Then(StorageClassSpecifier) .Then(DeclnSpecs.Add) ).Or( Given <DeclnSpecs>() .Then(TypeSpecifier) .Then(DeclnSpecs.Add) ).Or( Given <DeclnSpecs>() .Then(TypeQualifier) .Then(DeclnSpecs.Add) ).OneOrMore() ) ); // Init-declarator-list // : Init-declarator [ ',' Init-declarator ]* InitDeclaratorList.Is( InitDeclarator.OneOrMore(Comma) ); // Init-declarator // : declarator [ '=' initializer ]? InitDeclarator.Is( (Declarator) .Then( (Assign).Then(Initializer).Optional() ).Then(InitDeclr.Create) ); // storage-class-specifier // : auto | register | static | extern | typedef StorageClassSpecifier.Is( Either(Auto) .Or(Register) .Or(Static) .Or(Extern) .Or(Typedef) ); // Type-specifier // : void // | char // | short // | int // | long // | float // | double // | signed // | unsigned // | struct-or-union-specifier // | enum-specifier // | typedef-name TypeSpecifier.Is( Either( Either(Void) .Or(Char) .Or(Short) .Or(Int) .Or(Long) .Or(Float) .Or(Double) .Or(Signed) .Or(Unsigned) .Then(kind => new BasicTypeSpec(kind) as TypeSpec) ) .Or(StructOrUnionSpecifier) .Or(EnumSpecifier) .Or(TypeDefName.Then(TypedefName.Create)) ); // type_qualifier // : const // | volatile TypeQualifier.Is( Either(Const).Or(Volatile) ); // declarator // : [pointer]? direct-declarator Declarator.Is( (Pointer.Optional()) .Then(DirectDeclarator) .Then(Declr.Create) ); // pointer // : [ '*' [Type-qualifier-list]? ]+ Pointer.Is( ( Mult. Then(TypeQualifierList.Optional(ImmutableList <TypeQual> .Empty)) .Then(PointerModifier.Create) ).OneOrMore() .Then(pointerModifiers => pointerModifiers.Reverse()) ); // parameter-Type-list // : parameter-list [ ',' '...' ]? ParameterTypeList.Is( ParameterList .Then( (Comma) .Then(Period).Then(Period).Then(Period) .Optional() ).Then(ParamTypeList.Create) ); // parameter-list // : parameter-declaration [ ',' parameter-declaration ]* ParameterList.Is( ParameterDeclaration.OneOrMore(Comma) ); // Type-qualifier-list // : [Type-qualifier]+ TypeQualifierList.Is( TypeQualifier.OneOrMore() ); // direct-declarator // : [ // identifier | '(' declarator ')' // ] [ // '[' [constant-expression]? ']' // | '(' [parameter-Type-list]? ')' // ]* DirectDeclarator.Is( ( Either( (Identifier).Then(Declr.Create) ).Or( (LeftParen).Then(Declarator).Then(RightParen) ) ).Then( Either( Given <Declr>() .Then(LeftBracket) .Then( ConstantExpression.Optional().Then(ArrayModifier.Create) ).Then(RightBracket) .Then(Declr.Add) ).Or( Given <Declr>() .Then(LeftParen) .Then( ParameterTypeList .Optional() .Then(FunctionModifier.Create) ).Then(RightParen) .Then(Declr.Add) ) .ZeroOrMore() ) ); // enum-specifier // : enum [identifier]? '{' enumerator-list '}' // | enum identifier EnumSpecifier.Is( (Enum) .Then( Either( Identifier.Optional() .Then(LeftCurlyBrace) .Then(EnumeratorList) .Then(RightCurlyBrace) .Then(EnumSpec.Create) ).Or( (Identifier) .Then(EnumSpec.Create) ) ) ); // enumerator-list // : enumerator [ ',' enumerator ]* EnumeratorList.Is( Enumerator.OneOrMore(Comma) ); // enumerator // : enumeration-constant [ '=' constant-expression ]? Enumerator.Is( EnumerationConstant .Then( (Assign) .Then(ConstantExpression) .Optional() ).Then(Enumr.Create) ); // enumeration-constant // : identifier EnumerationConstant.Is( Identifier ); // struct-or-union-specifier // : struct-or-union [identifier]? { struct-declaration-list } // | struct-or-union identifier StructOrUnionSpecifier.Is( (StructOrUnion) .Then( Either( Given <StructOrUnion>() .Then(Identifier.Optional()) .Then(LeftCurlyBrace) .Then(StructDeclarationList) .Then(RightCurlyBrace) .Then(StructOrUnionSpec.Create) ).Or( Given <StructOrUnion>() .Then(Identifier) .Then(StructOrUnionSpec.Create) ) ) ); // struct-or-union // : struct | union StructOrUnion.Is( Either(Struct).Or(Union) ); // struct-declaration-list // : [struct-declaration]+ StructDeclarationList.Is( StructDeclaration.OneOrMore() ); // struct-declaration // : specifier-qualifier-list struct-declarator-list ';' StructDeclaration.Is( (SpecifierQualifierList) .Then(StructDeclaratorList) .Then(Semicolon) .Then(StructDecln.Create) ); // specifier-qualifier-list // : [ Type-specifier | Type-qualifier ]+ SpecifierQualifierList.Is( Parser.Seed(SpecQualList.Empty) .Then( Either( Given <SpecQualList>() .Then(TypeSpecifier) .Then(SpecQualList.Add) ).Or( Given <SpecQualList>() .Then(TypeQualifier) .Then(SpecQualList.Add) ) .OneOrMore() ) ); // struct-declarator-list // : struct-declarator [ ',' struct-declarator ]* StructDeclaratorList.Is( StructDeclarator.OneOrMore(Comma) ); // struct-declarator // : [declarator]? ':' constant-expression // | declarator StructDeclarator.Is( Either( (Declarator.Optional()) .Then(Colon) .Then(ConstantExpression) .Then(StructDeclr.Create) ).Or( (Declarator) .Then(StructDeclr.Create) ) ); // parameter-declaration // : declaration-specifiers [ declarator | abstract-declarator ]? ParameterDeclaration.Is( (DeclarationSpecifiers) .Then( Either( (Declarator).Then(ParamDeclr.Create) ).Or( (AbstractDeclarator).Then(ParamDeclr.Create) ).Optional() ).Then(ParamDecln.Create) ); // abstract-declarator // : [pointer]? direct-abstract-declarator // | pointer AbstractDeclarator.Is( Either( (Pointer.Optional(ImmutableList <PointerModifier> .Empty)) .Then(DirectAbstractDeclarator) .Then(AbstractDeclr.Add) ).Or( (Pointer) .Then(AbstractDeclr.Create) ) ); // direct-abstract-declarator // : [ // '(' abstract-declarator ')' // | '[' [constant-expression]? ']' // array modifier // | '(' [parameter-type_list]? ')' // function modifier // ] [ // '[' [constant-expression]? ']' // array modifier // | '(' [parameter-Type-list]? ')' // function modifier // ]* DirectAbstractDeclarator.Is( ( Either( (LeftParen) .Then(AbstractDeclarator) .Then(RightParen) ).Or( (LeftBracket) .Then(ConstantExpression.Optional()) .Then(RightBracket) .Then(ArrayModifier.Create) .Then <ArrayModifier, ImmutableList <ArrayModifier> >(ImmutableList.Create) .Then(AbstractDeclr.Create) ).Or( (LeftParen) .Then(ParameterTypeList.Optional()) .Then(RightParen) .Then(FunctionModifier.Create) .Then <FunctionModifier, ImmutableList <FunctionModifier> >(ImmutableList.Create) .Then(AbstractDeclr.Create) ) ).Then( Either( Given <AbstractDeclr>() .Then( LeftBracket .Then(ConstantExpression.Optional()) .Then(RightBracket) .Then(ArrayModifier.Create) ).Then( AbstractDeclr.Add ) ).Or( Given <AbstractDeclr>() .Then( (LeftParen) .Then(ParameterTypeList.Optional()) .Then(RightParen) .Then(FunctionModifier.Create) ).Then( AbstractDeclr.Add ) ) .ZeroOrMore() ) ); // initializer // : assignment-expression // | '{' initializer-list '}' // | '{' initializer-list ',' '}' Initializer.Is( Either <Initr>( (AssignmentExpression) .Then(InitExpr.Create) ).Or( (LeftCurlyBrace) .Then(InitializerList) .Then(RightCurlyBrace) ).Or( (LeftCurlyBrace) .Then(InitializerList) .Then(Comma) .Then(RightCurlyBrace) ) ); // initializer-list // : initializer [ ',' initializer ]* InitializerList.Is( Initializer.OneOrMore(Comma) .Then(InitList.Create) ); // Type-name // : specifier-qualifier-list [abstract-declarator]? TypeName.Is( (SpecifierQualifierList) .Then(AbstractDeclarator.Optional()) .Then(AST.TypeName.Create) ); // typedef-name // : identifier TypeDefName.Is( (Identifier) .Check( result => result.Environment.IsTypedefName(result.Result) ) ); }
public PointerDeclarator(Pointer pointer, Declarator decl) { Pointer = pointer; InnerDeclarator = decl; }
private void Run(DeclSpec[] declSpecs, Declarator decl) { var ndte = new NamedDataTypeExtractor(declSpecs, parserState); this.nt = ndte.GetNameAndType(decl); }
private void Run(DeclSpec[] declSpecs, Declarator decl) { var ndte = new NamedDataTypeExtractor(platform, declSpecs, symbolTable); this.nt = ndte.GetNameAndType(decl); }
public Declarator (Declarator clone, Expression initializer) { this.li = clone.li; this.initializer = initializer; }
public ParamDecl ParamDecl(List<CAttribute> attrs, List<DeclSpec> dsl, Declarator decl) { return new ParamDecl { Attributes = attrs, DeclSpecs = dsl, Declarator = decl, }; }