carbon-language/carbon-lang
1
0
Fork 0
mirror of https://github.com/carbon-language/carbon-lang.git synced 2026-09-24 20:20:10 +01:00
Code Issues Packages Projects Releases 10 Wiki Activity

lowerCamelCase => snake_case (#396)

Browse Source
This commit is contained in:
Dave Abrahams
2021-03-17 13:09:58 -07:00
committed by GitHub
parent 71a8d072b4
commit 7e1721dc01
10 changed files with 105 additions and 103 deletions
Download Patch File Download Diff File Expand all files Collapse all files
executable_semantics/ast/declaration.h
+3 -3
View File
@@ -141,9 +141,9 @@ struct ChoiceDeclaration {
// Global variable definition implements the Declaration concept.
class VariableDeclaration {
public:
VariableDeclaration(int sourceLocation, std::string name, Expression* type,
VariableDeclaration(int source_location, std::string name, Expression* type,
Expression* initializer)
: sourceLocation(sourceLocation),
: source_location(source_location),
name(name),
type(type),
initializer(initializer) {}
@@ -155,7 +155,7 @@ class VariableDeclaration {
auto TopLevel(ExecutionEnvironment&) const -> void;
private:
int sourceLocation;
int source_location;
std::string name;
Expression* type;
Expression* initializer;
executable_semantics/interpreter/interpreter.cpp
+18 -18
View File
@@ -322,15 +322,15 @@ void CallFunction(int line_num, std::vector<Value*> operas, State* state) {
case ValKind::FunV: {
// Bind arguments to parameters
std::list<std::string> params;
std::optional<Env> envWithMatches = PatternMatch(
std::optional<Env> env_with_matches = PatternMatch(
operas[0]->u.fun.param, operas[1], globals, &params, line_num);
if (!envWithMatches) {
if (!env_with_matches) {
std::cerr << "internal error in call_function, pattern match failed"
<< std::endl;
exit(-1);
}
// Create the new frame and push it on the stack
auto* scope = new Scope(*envWithMatches, params);
auto* scope = new Scope(*env_with_matches, params);
auto* frame = new Frame(*operas[0]->u.fun.name, Stack(scope),
Stack(MakeStmtAct(operas[0]->u.fun.body)));
state->stack.Push(frame);
@@ -420,12 +420,12 @@ auto PatternMatch(Value* p, Value* v, Env env, std::list<std::string>* vars,
std::cerr << std::endl;
exit(-1);
}
std::optional<Env> envWithMatches = PatternMatch(
std::optional<Env> env_with_matches = PatternMatch(
state->heap[elt.second], state->heap[*a], env, vars, line_num);
if (!envWithMatches) {
if (!env_with_matches) {
return std::nullopt;
}
env = *envWithMatches;
env = *env_with_matches;
} // for
return env;
}
@@ -443,12 +443,12 @@ auto PatternMatch(Value* p, Value* v, Env env, std::list<std::string>* vars,
*p->u.alt.alt_name != *v->u.alt.alt_name) {
return std::nullopt;
}
std::optional<Env> envWithMatches =
std::optional<Env> env_with_matches =
PatternMatch(p->u.alt.arg, v->u.alt.arg, env, vars, line_num);
if (!envWithMatches) {
if (!env_with_matches) {
return std::nullopt;
}
return *envWithMatches;
return *env_with_matches;
}
default:
std::cerr
@@ -461,13 +461,13 @@ auto PatternMatch(Value* p, Value* v, Env env, std::list<std::string>* vars,
case ValKind::FunctionTV:
switch (v->tag) {
case ValKind::FunctionTV: {
std::optional<Env> envWithMatches = PatternMatch(
std::optional<Env> env_with_matches = PatternMatch(
p->u.fun_type.param, v->u.fun_type.param, env, vars, line_num);
if (!envWithMatches) {
if (!env_with_matches) {
return std::nullopt;
}
return PatternMatch(p->u.fun_type.ret, v->u.fun_type.ret,
*envWithMatches, vars, line_num);
*env_with_matches, vars, line_num);
}
default:
return std::nullopt;
@@ -1165,17 +1165,17 @@ void HandleValue() {
Value* v = act->results[0];
Value* p = act->results[1];
std::optional<Env> envWithMatches =
std::optional<Env> env_with_matches =
PatternMatch(p, v, frame->scopes.Top()->env,
&frame->scopes.Top()->locals, stmt->line_num);
if (!envWithMatches) {
if (!env_with_matches) {
std::cerr
<< stmt->line_num
<< ": internal error in variable definition, match failed"
<< std::endl;
exit(-1);
}
frame->scopes.Top()->env = *envWithMatches;
frame->scopes.Top()->env = *env_with_matches;
frame->todo.Pop(2);
}
break;
@@ -1259,10 +1259,10 @@ void HandleValue() {
auto pat = act->results[clause_num + 1];
auto env = CurrentEnv(state);
std::list<std::string> vars;
std::optional<Env> envWithMatches =
std::optional<Env> env_with_matches =
PatternMatch(pat, v, env, &vars, stmt->line_num);
if (envWithMatches) { // we have a match, start the body
auto* new_scope = new Scope(*envWithMatches, vars);
if (env_with_matches) { // we have a match, start the body
auto* new_scope = new Scope(*env_with_matches, vars);
frame->scopes.Push(new_scope);
Statement* body_block = MakeBlock(stmt->line_num, c->second);
Action* body_act = MakeStmtAct(body_block);
executable_semantics/interpreter/typecheck.cpp
+6 -6
View File
@@ -650,11 +650,11 @@ auto ChoiceDeclaration::TypeChecked(TypeEnv env, Env ct_env) const
// declaration with annotated types.
auto VariableDeclaration::TypeChecked(TypeEnv env, Env ct_env) const
-> Declaration {
TCResult typeCheckedInitializer =
TCResult type_checked_initializer =
TypeCheckExp(initializer, env, ct_env, nullptr, TCContext::ValueContext);
Value* declaredType = ToType(sourceLocation, InterpExp(ct_env, type));
ExpectType(sourceLocation, "initializer of variable", declaredType,
typeCheckedInitializer.type);
Value* declared_type = ToType(source_location, InterpExp(ct_env, type));
ExpectType(source_location, "initializer of variable", declared_type,
type_checked_initializer.type);
return *this;
}
@@ -706,8 +706,8 @@ auto ChoiceDeclaration::TopLevel(ExecutionEnvironment& tops) const -> void {
// Associate the variable name with it's declared type in the
// compile-time symbol table.
auto VariableDeclaration::TopLevel(ExecutionEnvironment& tops) const -> void {
Value* declaredType = ToType(sourceLocation, InterpExp(tops.second, type));
tops.first.Set(Name(), declaredType);
Value* declared_type = ToType(source_location, InterpExp(tops.second, type));
tops.first.Set(Name(), declared_type);
}
} // namespace Carbon
executable_semantics/main.cpp
+6 -6
View File
@@ -17,22 +17,22 @@ int main(int argc, char* argv[]) {
using llvm::cl::desc;
using llvm::cl::opt;
opt<bool> trace_option("trace", desc("Enable tracing"));
opt<std::string> inputFileName(llvm::cl::Positional, desc("<input file>"),
llvm::cl::Required);
opt<std::string> input_file_name(llvm::cl::Positional, desc("<input file>"),
llvm::cl::Required);
llvm::cl::ParseCommandLineOptions(argc, argv);
if (trace_option) {
Carbon::tracing_output = true;
}
std::variant<Carbon::AST, Carbon::SyntaxErrorCode> astOrError =
Carbon::parse(inputFileName);
std::variant<Carbon::AST, Carbon::SyntaxErrorCode> ast_or_error =
Carbon::parse(input_file_name);
if (auto* error = std::get_if<Carbon::SyntaxErrorCode>(&astOrError)) {
if (auto* error = std::get_if<Carbon::SyntaxErrorCode>(&ast_or_error)) {
// Diagnostic already reported to std::cerr; this is just a return code.
return *error;
}
// Typecheck and run the parsed program.
Carbon::ExecProgram(std::get<Carbon::AST>(astOrError));
Carbon::ExecProgram(std::get<Carbon::AST>(ast_or_error));
}
executable_semantics/syntax/lexer.lpp
+52 -52
View File
@@ -55,7 +55,7 @@ horizontal_whitespace [ \t\r]
//
// Advances the current token position by yyleng columns without changing
// the line number.
# define YY_USER_ACTION context.currentTokenPosition.columns(yyleng);
# define YY_USER_ACTION context.current_token_position.columns(yyleng);
%}
%%
@@ -64,92 +64,92 @@ horizontal_whitespace [ \t\r]
// Code run each time yylex is called.
// Begin with an empty token span starting where its previous end was.
context.currentTokenPosition.step();
context.current_token_position.step();
%}
{AND} { return yy::parser::make_AND(context.currentTokenPosition); }
{ARROW} { return yy::parser::make_ARROW(context.currentTokenPosition); }
{AUTO} { return yy::parser::make_AUTO(context.currentTokenPosition); }
{BOOL} { return yy::parser::make_BOOL(context.currentTokenPosition); }
{BREAK} { return yy::parser::make_BREAK(context.currentTokenPosition); }
{CASE} { return yy::parser::make_CASE(context.currentTokenPosition); }
{CHOICE} { return yy::parser::make_CHOICE(context.currentTokenPosition); }
{CONTINUE} { return yy::parser::make_CONTINUE(context.currentTokenPosition); }
{DBLARROW} { return yy::parser::make_DBLARROW(context.currentTokenPosition); }
{DEFAULT} { return yy::parser::make_DEFAULT(context.currentTokenPosition); }
{ELSE} { return yy::parser::make_ELSE(context.currentTokenPosition); }
"==" { return yy::parser::make_EQUAL_EQUAL(context.currentTokenPosition); }
{FALSE} { return yy::parser::make_FALSE(context.currentTokenPosition); }
{FN} { return yy::parser::make_FN(context.currentTokenPosition); }
{FNTY} { return yy::parser::make_FNTY(context.currentTokenPosition); }
{IF} { return yy::parser::make_IF(context.currentTokenPosition); }
{INT} { return yy::parser::make_INT(context.currentTokenPosition); }
{MATCH} { return yy::parser::make_MATCH(context.currentTokenPosition); }
{NOT} { return yy::parser::make_NOT(context.currentTokenPosition); }
{OR} { return yy::parser::make_OR(context.currentTokenPosition); }
{RETURN} { return yy::parser::make_RETURN(context.currentTokenPosition); }
{STRUCT} { return yy::parser::make_STRUCT(context.currentTokenPosition); }
{TRUE} { return yy::parser::make_TRUE(context.currentTokenPosition); }
{TYPE} { return yy::parser::make_TYPE(context.currentTokenPosition); }
{VAR} { return yy::parser::make_VAR(context.currentTokenPosition); }
{WHILE} { return yy::parser::make_WHILE(context.currentTokenPosition); }
{AND} { return yy::parser::make_AND(context.current_token_position); }
{ARROW} { return yy::parser::make_ARROW(context.current_token_position); }
{AUTO} { return yy::parser::make_AUTO(context.current_token_position); }
{BOOL} { return yy::parser::make_BOOL(context.current_token_position); }
{BREAK} { return yy::parser::make_BREAK(context.current_token_position); }
{CASE} { return yy::parser::make_CASE(context.current_token_position); }
{CHOICE} { return yy::parser::make_CHOICE(context.current_token_position); }
{CONTINUE} { return yy::parser::make_CONTINUE(context.current_token_position); }
{DBLARROW} { return yy::parser::make_DBLARROW(context.current_token_position); }
{DEFAULT} { return yy::parser::make_DEFAULT(context.current_token_position); }
{ELSE} { return yy::parser::make_ELSE(context.current_token_position); }
"==" { return yy::parser::make_EQUAL_EQUAL(context.current_token_position); }
{FALSE} { return yy::parser::make_FALSE(context.current_token_position); }
{FN} { return yy::parser::make_FN(context.current_token_position); }
{FNTY} { return yy::parser::make_FNTY(context.current_token_position); }
{IF} { return yy::parser::make_IF(context.current_token_position); }
{INT} { return yy::parser::make_INT(context.current_token_position); }
{MATCH} { return yy::parser::make_MATCH(context.current_token_position); }
{NOT} { return yy::parser::make_NOT(context.current_token_position); }
{OR} { return yy::parser::make_OR(context.current_token_position); }
{RETURN} { return yy::parser::make_RETURN(context.current_token_position); }
{STRUCT} { return yy::parser::make_STRUCT(context.current_token_position); }
{TRUE} { return yy::parser::make_TRUE(context.current_token_position); }
{TYPE} { return yy::parser::make_TYPE(context.current_token_position); }
{VAR} { return yy::parser::make_VAR(context.current_token_position); }
{WHILE} { return yy::parser::make_WHILE(context.current_token_position); }
"=" return yy::parser::make_EQUAL(context.currentTokenPosition);
"-" return yy::parser::make_MINUS(context.currentTokenPosition);
"+" return yy::parser::make_PLUS(context.currentTokenPosition);
"*" return yy::parser::make_STAR(context.currentTokenPosition);
"/" return yy::parser::make_SLASH(context.currentTokenPosition);
"(" return yy::parser::make_LEFT_PARENTHESIS(context.currentTokenPosition);
")" return yy::parser::make_RIGHT_PARENTHESIS(context.currentTokenPosition);
"{" return yy::parser::make_LEFT_CURLY_BRACE(context.currentTokenPosition);
"}" return yy::parser::make_RIGHT_CURLY_BRACE(context.currentTokenPosition);
"[" return yy::parser::make_LEFT_SQUARE_BRACKET(context.currentTokenPosition);
"]" return yy::parser::make_RIGHT_SQUARE_BRACKET(context.currentTokenPosition);
"." return yy::parser::make_PERIOD(context.currentTokenPosition);
"," return yy::parser::make_COMMA(context.currentTokenPosition);
";" return yy::parser::make_SEMICOLON(context.currentTokenPosition);
":" return yy::parser::make_COLON(context.currentTokenPosition);
"=" return yy::parser::make_EQUAL(context.current_token_position);
"-" return yy::parser::make_MINUS(context.current_token_position);
"+" return yy::parser::make_PLUS(context.current_token_position);
"*" return yy::parser::make_STAR(context.current_token_position);
"/" return yy::parser::make_SLASH(context.current_token_position);
"(" return yy::parser::make_LEFT_PARENTHESIS(context.current_token_position);
")" return yy::parser::make_RIGHT_PARENTHESIS(context.current_token_position);
"{" return yy::parser::make_LEFT_CURLY_BRACE(context.current_token_position);
"}" return yy::parser::make_RIGHT_CURLY_BRACE(context.current_token_position);
"[" return yy::parser::make_LEFT_SQUARE_BRACKET(context.current_token_position);
"]" return yy::parser::make_RIGHT_SQUARE_BRACKET(context.current_token_position);
"." return yy::parser::make_PERIOD(context.current_token_position);
"," return yy::parser::make_COMMA(context.current_token_position);
";" return yy::parser::make_SEMICOLON(context.current_token_position);
":" return yy::parser::make_COLON(context.current_token_position);
{identifier} {
int n = strlen(yytext);
auto r = reinterpret_cast<char*>(malloc((n + 1) * sizeof(char)));
strncpy(r, yytext, n + 1);
return yy::parser::make_identifier(r, context.currentTokenPosition);
return yy::parser::make_identifier(r, context.current_token_position);
}
{integer_literal} {
auto r = atof(yytext);
return yy::parser::make_integer_literal(r, context.currentTokenPosition);
return yy::parser::make_integer_literal(r, context.current_token_position);
}
{ONE_LINE_COMMENT} {
// Advance end by 1 line, resetting the column to zero.
context.currentTokenPosition.lines(1);
context.current_token_position.lines(1);
// Make the span empty by setting start to end.
context.currentTokenPosition.step();
context.current_token_position.step();
}
{horizontal_whitespace}+ {
// Make the span empty by setting start to end.
context.currentTokenPosition.step();
context.current_token_position.step();
}
\n+ {
// Advance end by yyleng lines, resetting the column to zero.
context.currentTokenPosition.lines(yyleng);
context.current_token_position.lines(yyleng);
// Make the span empty by setting start to end.
context.currentTokenPosition.step();
context.current_token_position.step();
}
. {
std::cerr << context.currentTokenPosition << ": invalid character '"
std::cerr << context.current_token_position << ": invalid character '"
<< yytext[0] << "' in source file." << std::endl;
std::exit(1);
}
<<EOF>> {
// A more modern Bison would give us make_EOF.
return yy::parser::make_END_OF_FILE(context.currentTokenPosition);
return yy::parser::make_END_OF_FILE(context.current_token_position);
}
%%
executable_semantics/syntax/parse.cpp
+10 -10
View File
@@ -17,29 +17,29 @@ namespace Carbon {
// Returns an abstract representation of the program contained in the
// well-formed input file, or if the file was malformed, a description of the
// problem.
auto parse(const std::string& inputFileName)
auto parse(const std::string& input_file_name)
-> std::variant<AST, SyntaxErrorCode> {
yyin = fopen(inputFileName.c_str(), "r");
yyin = fopen(input_file_name.c_str(), "r");
if (yyin == nullptr) {
std::cerr << "Error opening '" << inputFileName
std::cerr << "Error opening '" << input_file_name
<< "': " << std::strerror(errno) << std::endl;
exit(1);
}
std::optional<AST> parsedInput = std::nullopt;
ParseAndLexContext context(inputFileName);
std::optional<AST> parsed_input = std::nullopt;
ParseAndLexContext context(input_file_name);
auto syntaxErrorCode = yy::parser(parsedInput, context)();
if (syntaxErrorCode != 0) {
return syntaxErrorCode;
auto syntax_error_code = yy::parser(parsed_input, context)();
if (syntax_error_code != 0) {
return syntax_error_code;
}
if (parsedInput == std::nullopt) {
if (parsed_input == std::nullopt) {
std::cerr << "Internal error: parser validated syntax yet didn't produce "
"an AST.\n";
exit(1);
}
return *parsedInput;
return *parsed_input;
}
} // namespace Carbon
executable_semantics/syntax/parse.h
+1 -1
View File
@@ -17,7 +17,7 @@ using SyntaxErrorCode = int;
// Returns the AST representing the contents of the named file, or an error code
// if parsing fails.
auto parse(const std::string& inputFileName)
auto parse(const std::string& input_file_name)
-> std::variant<Carbon::AST, SyntaxErrorCode>;
} // namespace Carbon
executable_semantics/syntax/parse_and_lex_context.cpp
+2 -1
View File
@@ -13,7 +13,8 @@
// the given line, to standard error.
auto Carbon::ParseAndLexContext::PrintDiagnostic(const std::string& message,
int line_num) -> void {
std::cerr << inputFileName << ":" << line_num << ": " << message << std::endl;
std::cerr << input_file_name << ":" << line_num << ": " << message
<< std::endl;
exit(-1); // TODO: do we really want this here? It makes the comment and the
// name a lie, and renders some of the other yyparse() result
// propagation code moot.
executable_semantics/syntax/parse_and_lex_context.h
+5 -4
View File
@@ -17,19 +17,20 @@ namespace Carbon {
class ParseAndLexContext {
public:
// Creates an instance analyzing the given input file.
ParseAndLexContext(const std::string& inputFile) : inputFileName(inputFile) {}
ParseAndLexContext(const std::string& input_file)
: input_file_name(input_file) {}
// Writes a syntax error diagnostic, containing message, for the input file at
// the given line, to standard error.
auto PrintDiagnostic(const std::string& message, int lineNumber) -> void;
auto PrintDiagnostic(const std::string& message, int line_number) -> void;
// The source range of the token being (or just) lex'd.
yy::location currentTokenPosition;
yy::location current_token_position;
private:
// A path to the file processed, relative to the current working directory
// when *this is called.
const std::string inputFileName;
const std::string input_file_name;
};
} // namespace Carbon
executable_semantics/syntax/parser.ypp
+2 -2
View File
@@ -26,7 +26,7 @@
// thus available to its methods.
// "out" parameter passed to the parser, where the AST is written.
%parse-param {std::optional<Carbon::AST>& parsedProgram}
%parse-param {std::optional<Carbon::AST>& parsed_program}
// "inout" parameter passed to both the parser and the lexer.
%param {Carbon::ParseAndLexContext& context}
@@ -151,7 +151,7 @@ void yy::parser::error(
%locations
%%
input: declaration_list
{ parsedProgram = $1; }
{ parsed_program = $1; }
;
pattern:
expression