public DECLARATION(Token n = null) { if (n != null) { name = new IDENTIFIER(n.image); } }
/// <summary> /// /// </summary> /// <syntax> /// Объявление-контейнера /// : [ Спецификатор-контейнера ] unit Имя-контейнера [ FormalGenerics ] /// { Директива-контейнера } /// is /// Тело-контейнера /// [ invariant Список-предикатов ] /// end /// /// Спецификатор-контейнера /// : ref | val | concurrent | abstract /// /// Имя-контейнера /// : Составное-имя /// /// Директива-контейнера /// : Директива-наследования /// | Директива-использования /// /// Директива-наследования /// : extend Базовый-контейнер { , Базовый-контейнер } /// /// Базовый-контейнер /// : [ ~ ] UnitTypeName /// /// Тело-контейнера /// : { Объявление } /// </syntax> /// <returns></returns> public static void parse(bool hidden, bool final, bool abstr, iSCOPE context) { Debug.Indent(); Debug.WriteLine("Entering UNIT.parse"); bool ref_val = false; // unit is reference by default bool concurrent = false; UNIT unit = null; Token token = get(); Token begin = token; TokenCode code = TokenCode.Unit; switch (token.code) { case TokenCode.Ref: ref_val = true; forget(); code = getUnitKeyword(); break; case TokenCode.Val: ref_val = false; forget(); code = getUnitKeyword(); break; case TokenCode.Abstract: abstr = true; forget(); code = getUnitKeyword(); break; case TokenCode.Concurrent: concurrent = true; forget(); code = getUnitKeyword(); break; case TokenCode.Unit: code = TokenCode.Unit; forget(); break; case TokenCode.Package: code = TokenCode.Package; forget(); break; } // 1. Unit header token = expect(TokenCode.Identifier); Token compoundName = IDENTIFIER.parseCompoundName(token); if (code == TokenCode.Package) { if (!ENTITY.options.optConfig) { warning(token, "no-config"); unit = new UNIT(compoundName.image, ref_val, abstr, concurrent); } else { unit = new PACKAGE(compoundName.image, ref_val, abstr, concurrent); } } else { unit = new UNIT(compoundName.image, ref_val, abstr, concurrent); } Debug.WriteLine("======================" + compoundName.image); unit.parent = context.self; unit.setSpecs(hidden, final); Context.enter(unit); // 2. Generic parameters token = get(); if (token.code == TokenCode.LBracket) { forget(); while (true) { var generic = FORMAL_GENERIC.parse(unit); unit.add(generic); token = get(); switch (token.code) { case TokenCode.Comma: case TokenCode.Semicolon: forget(); continue; case TokenCode.RBracket: forget(); goto Finish; default: { /* Syntax error */ break; } } } Finish: ; } // Possible unit alias token = get(); if (token.code == TokenCode.Alias) { forget(); token = expect(TokenCode.Identifier); unit.alias = new IDENTIFIER(token); } // 3. Unit directives: inheritance token = get(); if (token.code == TokenCode.Extend) { forget(); while (true) { PARENT parent = PARENT.parse(unit); if (parent == null) /* Syntax error */ break { ; } unit.add(parent); token = get(); switch (token.code) { case TokenCode.Comma: case TokenCode.Semicolon: case TokenCode.EOL: forget(); continue; default: goto Use; } } }
public static DECLARATION find(IDENTIFIER id) { return(find(id.identifier)); }
/// <summary> /// /// </summary> /// <syntax> /// UnitTypeName : CompoundName [ GenericInstantiation ] /// /// GenericInstantiation : "[" (Type|Expression) { "," (Type|Expression) } "]" /// </syntax> /// <returns></returns> public static UNIT_REF parse(Token id, bool opt, iSCOPE context) { Debug.Indent(); Debug.WriteLine("Entering UNIT_REF.parse"); Token token = null; // We assume that 'id' is 'identifier'. if (id == null) { token = get(); forget(); } else { token = id; } token = IDENTIFIER.parseCompoundName(token); if (token == null) /* an error was detected earlier */ return { (null); } Token start = token; UNIT_REF unit_ref = new UNIT_REF(token.image); unit_ref.opt = opt; unit_ref.as_sign = true; DECLARATION unit = Context.find(token); if (unit != null && (unit is UNIT || unit is FORMAL_TYPE)) { unit_ref.unit_ref = unit; } token = get(); if (token.code == TokenCode.LBracket) { forget(); while (true) { TYPE type = null; token = get(); if (token.code == TokenCode.LParen) { type = TUPLE_TYPE.parse(context); unit_ref.add(type); goto Delimiter; } EXPRESSION expr = EXPRESSION.parse(null, context); if (expr is REFERENCE || expr is UNRESOLVED) { string name = null; if (expr is REFERENCE) { if ((expr as REFERENCE).declaration is UNIT) { name = (expr as REFERENCE).declaration.name.identifier; } else { goto NonType; } } else // UNRESOLVED { name = (expr as UNRESOLVED).name.identifier; } id = new Token(expr.span, TokenCode.Identifier, name, new Category(CategoryCode.identifier)); type = UNIT_REF.parse(id, false, context); // Recursive call unit_ref.add(type); type.parent = unit_ref; goto Delimiter; } // else -- expr is perhaps a non-type argument NonType: token = get(); if (token.code == TokenCode.DotDot) { // This is actually a range _type_ forget(); EXPRESSION right = EXPRESSION.parse(null, context); RANGE_TYPE range = new RANGE_TYPE(expr, right); range.setSpan(expr.span, right.span); unit_ref.add(range); range.parent = unit_ref; } else // Definitely a non-type argument { unit_ref.add(expr); expr.parent = unit_ref; } Delimiter: token = get(); switch (token.code) { case TokenCode.Comma: forget(); continue; case TokenCode.RBracket: forget(); goto Finish; default: { /* Syntax error in generic actuals */ break; } } } Finish: unit_ref.setSpan(start.span, token.span); } else { unit_ref.setSpan(start); } Debug.WriteLine("Exiting UNIT_REF.parse"); Debug.Unindent(); return(unit_ref); }
public static new EXPRESSION parse(Token first, iSCOPE context) { EXPRESSION result = PRIMARY.parse(first, context); if (result == null) { return(null); } Span begin = result.span; while (true) { Token token = get(); switch (token.code) { case TokenCode.Dot: forget(); IDENTIFIER identifier; token = get(); if (token.code == TokenCode.Init) { forget(); // Initializer call in full form identifier = new IDENTIFIER(INITIALIZER.initName); } else if (token.code == TokenCode.Identifier) { forget(); identifier = new IDENTIFIER(token); } else // syntax error { identifier = new IDENTIFIER("ERROR"); } result = new MEMBER(result, identifier); result.setSpan(begin, token.span); break; case TokenCode.LParen: forget(); result = new CALL(result); while (true) { token = get(); if (token.code == TokenCode.RParen) { forget(); break; } EXPRESSION actual = EXPRESSION.parse(null, context); (result as CALL).add(actual); token = get(); if (token.code == TokenCode.Comma) { forget(); continue; } token = expect(TokenCode.RParen); break; } result.setSpan(begin, token.span); break; default: goto Out; } } Out: return(result); }
public UNRESOLVED(iSCOPE context, IDENTIFIER n) { ownScope = context; name = n; }
public MEMBER(EXPRESSION prefix, IDENTIFIER member) { this.secondary = prefix; prefix.parent = this; this.member = member; member.parent = this; }
public DECLARATION(IDENTIFIER n) { name = n; }
public DECLARATION(string n) { name = new IDENTIFIER(n); }
public VARIABLE(IDENTIFIER n = null, TYPE t = null, EXPRESSION i = null) : base(n) { type = t; initializer = i; }